diff --git a/PWGCF/Femto/FemtoNuclei/TableProducer/HadNucleiFemto.cxx b/PWGCF/Femto/FemtoNuclei/TableProducer/HadNucleiFemto.cxx
index a9d400bd3af..146aae79d92 100644
--- a/PWGCF/Femto/FemtoNuclei/TableProducer/HadNucleiFemto.cxx
+++ b/PWGCF/Femto/FemtoNuclei/TableProducer/HadNucleiFemto.cxx
@@ -67,6 +67,7 @@
 #include <cstdint>
 #include <cstdlib>
 #include <string>
+#include <utility>
 #include <vector>
 
 using namespace o2;
@@ -357,9 +358,9 @@ struct HadNucleiFemto {
   ConfigurableAxis axisVertex{"axisVertex", {30, -10, 10}, "Binning for vtxz"};
   ConfigurableAxis axisCentrality{"axisCentrality", {40, 0, 100}, "Binning for centrality"};
   using BinningType = ColumnBinningPolicy<aod::collision::PosZ, aod::cent::CentFT0C>;
+  using SelectedCollisions = soa::Filtered<CollisionsFull>;
   BinningType binningPolicy{{axisVertex, axisCentrality}, true};
   SliceCache cache;
-  SameKindPair<CollisionsFull, TrackCandidates, BinningType> mPair{binningPolicy, eventMixing.settingNoMixedEvents, -1, &cache};
   // Pair<CollisionsFull, TrackCandidates, o2::aod::DataHypCandsWColl, BinningType> hyperPair{binningPolicy, eventMixing.settingNoMixedEvents, -1, &cache};
 
   std::array<float, 6> mBBparamsNucleus{};
@@ -383,6 +384,7 @@ struct HadNucleiFemto {
      {"hCentrality", "Centrality", {HistType::kTH1F, {{100, 0.0f, 100.0f}}}},
      {"hSkipReasons", "Why storedEvent skipped;Reason;Counts", {HistType::kTH1F, {{5, -0.5, 4.5}}}},
      {"hEvents", "; Events;", {HistType::kTH1F, {{3, -0.5, 2.5}}}},
+     {"hMixedEventSelections", "Mixed-event collision selection;Step;Counts", {HistType::kTH1F, {{4, -0.5, 3.5}}}},
 
      // Candidate topology and kinematics
      {"hTrackSel", "Accepted hadron tracks", {HistType::kTH1F, {{Selections::kAll, -0.5, static_cast<double>(Selections::kAll) - 0.5}}}},
@@ -535,6 +537,11 @@ struct HadNucleiFemto {
     for (int i = 0; i < Selections::kAll; i++) {
       mQaRegistry.get<TH1>(HIST("hEvents"))->GetXaxis()->SetBinLabel(i + 1, eventsLabels[i].c_str());
     }
+
+    const std::array<std::string, 4> mixedEventLabels = {"All collisions", "Event selection", "Mixing pool", "Mixed combinations"};
+    for (size_t i = 0; i < mixedEventLabels.size(); i++) {
+      mQaRegistry.get<TH1>(HIST("hMixedEventSelections"))->GetXaxis()->SetBinLabel(i + 1, mixedEventLabels[i].c_str());
+    }
   }
 
   template <bool isMC>
@@ -594,7 +601,7 @@ struct HadNucleiFemto {
   // ==================================================================================================================
 
   template <bool isMC, typename Tcollision>
-  bool passesCollisionSelection(const Tcollision& collision)
+  bool passesEventSelection(const Tcollision& collision)
   {
     // CPR uses phi* and therefore needs the magnetic field for MC as well.
     auto bc = collision.template bc_as<aod::BCsWithTimestamps>();
@@ -608,32 +615,41 @@ struct HadNucleiFemto {
       if (!collision.sel8() || std::abs(collision.posZ()) > eventMixing.settingCutVertex) {
         return false;
       }
-      if (zorro.settingSkimmedProcessing) {
-        if (!mZorro.isSelected(bc.globalBC())) {
-          return false;
-        }
-      }
     }
 
     return true;
   }
 
+  template <typename Tcollision>
+  bool passesZorroSelection(const Tcollision& collision)
+  {
+    if (!zorro.settingSkimmedProcessing) {
+      return true;
+    }
+    auto bc = collision.template bc_as<aod::BCsWithTimestamps>();
+    return mZorro.isSelected(bc.globalBC());
+  }
+
   template <bool isMC, typename Tcollision>
   bool selectCollision(const Tcollision& collision, const aod::BCsWithTimestamps&)
   {
     mQaRegistry.fill(HIST("hEvents"), 0);
 
-    if (!passesCollisionSelection<isMC>(collision)) {
+    if (!passesEventSelection<isMC>(collision)) {
       return false;
     }
 
+    mQaRegistry.fill(HIST("hEvents"), 1);
+
     if constexpr (!isMC) {
       if (zorro.settingSkimmedProcessing) {
+        if (!passesZorroSelection(collision)) {
+          return false;
+        }
         mQaRegistry.fill(HIST("hEvents"), 2);
       }
     }
 
-    mQaRegistry.fill(HIST("hEvents"), 1);
     mQaRegistry.fill(HIST("hNcontributor"), collision.numContrib());
     mQaRegistry.fill(HIST("hVtxZ"), collision.posZ());
     return true;
@@ -2195,10 +2211,31 @@ struct HadNucleiFemto {
   {
     LOG(debug) << "Processing mixed event";
 
-    for (const auto& [c1, tracks1, c2, tracks2] : mPair) {
-      if (!passesCollisionSelection</*isMC*/ false>(c1) || !passesCollisionSelection</*isMC*/ false>(c2)) {
+    // Zorro is a runtime selection, so build its filtered collision table before applying the mixing depth.
+    soa::SelectionVector selectedCollisionRows;
+    int64_t rowIndex = 0;
+    for (const auto& collision : collisions) {
+      mQaRegistry.fill(HIST("hMixedEventSelections"), 0);
+      if (!passesEventSelection</*isMC*/ false>(collision)) {
+        ++rowIndex;
         continue;
       }
+      mQaRegistry.fill(HIST("hMixedEventSelections"), 1);
+      if (!passesZorroSelection(collision)) {
+        ++rowIndex;
+        continue;
+      }
+      selectedCollisionRows.push_back(rowIndex++);
+      mQaRegistry.fill(HIST("hMixedEventSelections"), 2);
+    }
+
+    SelectedCollisions selectedCollisions{{collisions.asArrowTableRef()}, std::move(selectedCollisionRows)};
+    collisions.copyIndexBindings(selectedCollisions);
+    auto tracksTuple = std::make_tuple(tracks);
+    SameKindPair<SelectedCollisions, TrackCandidates, BinningType> selectedPairs{binningPolicy, eventMixing.settingNoMixedEvents, -1, selectedCollisions, tracksTuple, &cache};
+
+    for (const auto& [c1, tracks1, c2, tracks2] : selectedPairs) {
+      mQaRegistry.fill(HIST("hMixedEventSelections"), 3);
 
       mQaRegistry.fill(HIST("hNcontributor"), c1.numContrib());
       mQaRegistry.fill(HIST("hVtxZ"), c1.posZ());