diff --git a/Control/AthenaBaseComps/src/AthFilterAlgorithm.cxx b/Control/AthenaBaseComps/src/AthFilterAlgorithm.cxx
index 55868f9d79c3c171d3293411f757c449840ba14e..73e0009f1e1590a273a498159084bd247bafbbc4 100644
--- a/Control/AthenaBaseComps/src/AthFilterAlgorithm.cxx
+++ b/Control/AthenaBaseComps/src/AthFilterAlgorithm.cxx
@@ -84,7 +84,7 @@ AthFilterAlgorithm::sysInitialize()
 
   // register ourselves with the cutFlowSvc
   if ( cutFlowSvc().retrieve().isSuccess()) {
-    m_cutID = cutFlowSvc()->registerFilter(this->name(), m_filterDescr);
+    m_cutID = cutFlowSvc()->registerFilter(this->name(), m_filterDescr, false);
     if (0 == m_cutID) {
       ATH_MSG_INFO("problem registering myself with cutflow-svc");
     } else {
@@ -105,15 +105,14 @@ AthFilterAlgorithm::setFilterPassed( bool state ) const
   AthAlgorithm::setFilterPassed(state);
 
   if (state) {
-    double evtWeight=1.0;
-
     const EventContext& ctx = Gaudi::Hive::currentContext();
     SG::ReadHandle<xAOD::EventInfo> evtInfo (m_eventInfoKey, ctx);
     // Only try to access the mcEventWeight if we are running on Monte Carlo, duhhh!
     if ( evtInfo->eventType(xAOD::EventInfo::IS_SIMULATION) ) {
-      evtWeight = evtInfo->mcEventWeight();
+      m_cutFlowSvc->addEvent(m_cutID, evtInfo->mcEventWeights());
+    } else {
+      m_cutFlowSvc->addEvent(m_cutID, 1.0);
     }
-    m_cutFlowSvc->addEvent(m_cutID,evtWeight);
   }
 }
 
diff --git a/Control/AthenaKernel/AthenaKernel/ICutFlowSvc.h b/Control/AthenaKernel/AthenaKernel/ICutFlowSvc.h
index d746fbf06d034433507f35ff09322a393ccc1b17..0d1e1ee31676fbcda7cd670a60a254c3b775a10a 100644
--- a/Control/AthenaKernel/AthenaKernel/ICutFlowSvc.h
+++ b/Control/AthenaKernel/AthenaKernel/ICutFlowSvc.h
@@ -45,8 +45,10 @@ public:
   /// Register filter in the CutFlowSvc and returns the CutID of the
   /// corresponding EventBookkeeper.
   /// This method should be used by filters that register themselves.
+  /// Systematic variations are optional.
   virtual CutIdentifier registerFilter( const std::string& name,
-                                        const std::string& description ) = 0;
+                                        const std::string& description,
+                                        bool nominalOnly ) = 0;
 
   /// Tells CutFlowSvc that a filter is used directly by an outputStream with
   /// a given logical context. The only foreseen client should the DecisionSvc,
@@ -54,15 +56,30 @@ public:
   virtual CutIdentifier registerTopFilter( const std::string& name,
                                            const std::string& description,
                                            unsigned int logic,
-                                           const std::string& outputStream ) = 0;
+                                           const std::string& outputStream,
+                                           bool nominalOnly ) = 0;
+
+  /// Register cut as child of a filter in the CutFlowSvc and returns the CutID
+  /// of the corresponding EventBookkeeper. This method should be used by
+  /// filters to register their internal cuts that are not the Algs themselves.
+  virtual CutIdentifier registerCut( const std::string& name,
+                                     const std::string& description,
+                                     CutIdentifier parentCutID,
+                                     bool nominalOnly ) = 0;
 
   /// Set the description of an existing EventBookkeeper
   virtual void setFilterDescription( CutIdentifier cutID,
                                      const std::string& descr ) = 0;
 
-  /// Tells CutFlowSvc to update the weighted event counter of a CutIdentifier cutID,
-  /// using CutIdentifier returned by selfRegisterFilter
-  virtual void addEvent( CutIdentifier cutID, double weight) = 0;
+  /// Tells CutFlowSvc to update the weighted event counter of a CutIdentifier
+  /// A vector of weights is provided for all systematic variations
+  virtual void addEvent( CutIdentifier cutID,
+                         const std::vector<float>& weights) = 0;
+
+  /// Tells CutFlowSvc to update the weighted event counter of a CutIdentifier
+  /// The same weight is for all systematic variations
+  virtual void addEvent( CutIdentifier cutID,
+                         double weight) = 0;
 
   /// Get number of accepted events for a cut
   virtual uint64_t getNAcceptedEvents( const CutIdentifier cutID ) const = 0;
diff --git a/Control/AthenaPython/python/PyAthenaComps.py b/Control/AthenaPython/python/PyAthenaComps.py
index 60301958e3b0ef1a6175a7235ec0ea569d413cee..bbf0313df8ed51e21018eba86b5673216a60d030 100644
--- a/Control/AthenaPython/python/PyAthenaComps.py
+++ b/Control/AthenaPython/python/PyAthenaComps.py
@@ -385,7 +385,7 @@ class AthFilterAlgorithm(Alg):
 
     def sysInitialize(self):
         myName=self.name() if callable(self.name) else self.name 
-        self.cutID = self.cutFlowSvc().registerFilter(myName, self._filter_descr)
+        self.cutID = self.cutFlowSvc().registerFilter(myName, self._filter_descr, True)
         if not self.cutID:
             self.msg.error("could not register filter-cut with cutflowsvc")
             return StatusCode.Failure
diff --git a/Control/AthenaServices/src/DecisionSvc.cxx b/Control/AthenaServices/src/DecisionSvc.cxx
index 0d60e1fe3583873c365348d16be9c700cf1b8796..e85a57b8b9bfc1f79952decdff35a5f14656aa78 100644
--- a/Control/AthenaServices/src/DecisionSvc.cxx
+++ b/Control/AthenaServices/src/DecisionSvc.cxx
@@ -434,7 +434,7 @@ void DecisionSvc::DeclareToCutFlowSvc()
       ATH_MSG_DEBUG("Declaring logic " << logicalKey << " for " << streamName);
       for (auto filter  = (*vec)->begin();
                 filter != (*vec)->end(); ++filter) {
-        if(!m_cutflowSvc.empty()) {m_cutflowSvc->registerTopFilter( (*filter), logicalKey, 2, streamName ); }
+        if(!m_cutflowSvc.empty()) {m_cutflowSvc->registerTopFilter( (*filter), logicalKey, 2, streamName, true ); } // TODO: validate
       }
     }
   }
diff --git a/Database/AthenaPOOL/AthenaPoolExample/AthenaPoolExampleAlgorithms/share/AthenaPoolExample_Write.ref b/Database/AthenaPOOL/AthenaPoolExample/AthenaPoolExampleAlgorithms/share/AthenaPoolExample_Write.ref
index 2becbbbeeee7d3d1b5be6d9cce5d63a197ba714c..73870aa96e19300ab34cf0b2a303e33fd6e3bd7e 100644
--- a/Database/AthenaPOOL/AthenaPoolExample/AthenaPoolExampleAlgorithms/share/AthenaPoolExample_Write.ref
+++ b/Database/AthenaPOOL/AthenaPoolExample/AthenaPoolExampleAlgorithms/share/AthenaPoolExample_Write.ref
@@ -1360,6 +1360,7 @@ Domain[ROOT_All]     INFO ->  Deaccess DbDatabase   CREATE    [ROOT_All] ????
 Domain[ROOT_All]     INFO >   Deaccess DbDomain     UPDATE    [ROOT_All] 
 ApplicationMgr       INFO Application Manager Stopped successfully
 IncidentProcAlg1     INFO Finalize
+AllExecutedEvents    INFO accepted 20 out of 20 events for filter AllExecutedEvents (Number of processed events before any cut)
 WriteData            INFO in finalize()
 WriteTag             INFO in finalize()
 MagicWriteTag        INFO in finalize()
diff --git a/Database/AthenaRoot/AthenaRootComps/share/POOLEventSelector_testJobOptions.py b/Database/AthenaRoot/AthenaRootComps/share/POOLEventSelector_testJobOptions.py
deleted file mode 100644
index c03b9bd21742c0a201289e23e7c06ecdea6b2793..0000000000000000000000000000000000000000
--- a/Database/AthenaRoot/AthenaRootComps/share/POOLEventSelector_testJobOptions.py
+++ /dev/null
@@ -1,17 +0,0 @@
-
-
-#this joboption is used in performance monitoring to compare to xAODEventSelector
-
-theApp.EvtMax = -1
-
-import os
-
-jps.AthenaCommonFlags.FilesInput = [os.environ.get("ASG_TEST_FILE_MC","/afs/cern.ch/user/a/asgbase/patspace/xAODs/r7725/mc15_13TeV.410000.PowhegPythiaEvtGen_P2012_ttbar_hdamp172p5_nonallhad.merge.AOD.e3698_s2608_s2183_r7725_r7676/AOD.07915862._000100.pool.root.1")]
-
-
-
-import AthenaPoolCnvSvc.ReadAthenaPool
-
-
-algseq = CfgMgr.AthSequencer("AthAlgSeq")
-algseq += CfgMgr.EventCounterAlg(BookkeepOtherMCEventWeights=True)
diff --git a/Database/AthenaRoot/AthenaRootComps/share/xAODEventSelector_testJobOptions.py b/Database/AthenaRoot/AthenaRootComps/share/xAODEventSelector_testJobOptions.py
deleted file mode 100644
index 224aebf4e92b8f3f766b04a855cbf9ac14008180..0000000000000000000000000000000000000000
--- a/Database/AthenaRoot/AthenaRootComps/share/xAODEventSelector_testJobOptions.py
+++ /dev/null
@@ -1,17 +0,0 @@
-
-
-#this joboption is used in performance monitoring to compare to POOL
-
-theApp.EvtMax = -1
-
-import os
-
-jps.AthenaCommonFlags.FilesInput = [os.environ.get("ASG_TEST_FILE_MC","/afs/cern.ch/user/a/asgbase/patspace/xAODs/r7725/mc15_13TeV.410000.PowhegPythiaEvtGen_P2012_ttbar_hdamp172p5_nonallhad.merge.AOD.e3698_s2608_s2183_r7725_r7676/AOD.07915862._000100.pool.root.1")]
-
-
-
-import AthenaRootComps.ReadAthenaxAODHybrid
-
-
-algseq = CfgMgr.AthSequencer("AthAlgSeq")
-algseq += CfgMgr.EventCounterAlg(BookkeepOtherMCEventWeights=True)
diff --git a/Event/EventBookkeeperTools/EventBookkeeperTools/CutFlowSvc.h b/Event/EventBookkeeperTools/EventBookkeeperTools/CutFlowSvc.h
index 51350e9391934e79ff811e7240de5af95f277e1e..7004df94c64f6795cce0390333a2a1a54a22a396 100644
--- a/Event/EventBookkeeperTools/EventBookkeeperTools/CutFlowSvc.h
+++ b/Event/EventBookkeeperTools/EventBookkeeperTools/CutFlowSvc.h
@@ -69,7 +69,8 @@ public:
   /// corresponding CutBookkeeper.
   /// This method should be used by filters that register themselves.
   virtual CutIdentifier registerFilter(const std::string& name,
-                                       const std::string& description)  override final;
+                                       const std::string& description,
+                                       bool nominalOnly) override final;
 
   /// Tells CutFlowSvc that a filter is used directly by an outputStream with
   /// a given logical context. The only foreseen client should the DecisionSvc,
@@ -77,12 +78,26 @@ public:
   virtual CutIdentifier registerTopFilter(const std::string& name,
                                           const std::string& description,
                                           unsigned int logic,
-                                          const std::string& outputStream) override final;
+                                          const std::string& outputStream,
+                                          bool nominalOnly) override final;
+
+  /// Register cut as child of a filter in the CutFlowSvc and returns the CutID
+  /// of the corresponding EventBookkeeper. This method should be used by
+  /// filters to register their internal cuts that are not the Algs themselves.
+  virtual CutIdentifier registerCut(const std::string& name,
+                                    const std::string& description,
+                                    CutIdentifier parentCutID,
+                                    bool nominalOnly) override final;
 
   /// Set the description of an existing CutBookkeeper
   virtual void setFilterDescription(CutIdentifier cutID,
                                     const std::string& descr) override final;
 
+  /// Tells CutFlowSvc to update the weighted event counter of a CutIdentifier cutID,
+  /// using CutIdentifier returned by selfRegisterFilter
+  virtual void addEvent(CutIdentifier cutID,
+                        const std::vector<float>& weights) override final;
+
   /// Tells CutFlowSvc to update the weighted event counter of a CutIdentifier cutID,
   /// using CutIdentifier returned by selfRegisterFilter
   virtual void addEvent(CutIdentifier cutID,
@@ -99,6 +114,12 @@ public:
 
 
 private:
+  /// Tells CutFlowSvc to update the weighted event counter of a CutIdentifier cutID
+  /// for a specific index in the cache
+  void addEvent(CutIdentifier cutID,
+                size_t index,
+                double weight);
+
   /// Helper function to determine the processing cycle number from the
   /// input meta-data store
   StatusCode determineCycleNumberFromInput(const std::string& collName);
@@ -130,6 +151,9 @@ private:
 
   /// Mutex to protect adding an event
   mutable std::recursive_mutex m_addEventMutex;
+
+  /// List of nominal-only filters
+  std::unordered_set<CutIdentifier> m_nominalOnlyCuts;
 };
 
 
diff --git a/Event/EventBookkeeperTools/Root/CutFlowSvc.cxx b/Event/EventBookkeeperTools/Root/CutFlowSvc.cxx
index 099b1caf0002e4c95354192a056f63f7bc20ebc1..3b366e8d7670b5b75d51cc7135dc094e2fa6995d 100644
--- a/Event/EventBookkeeperTools/Root/CutFlowSvc.cxx
+++ b/Event/EventBookkeeperTools/Root/CutFlowSvc.cxx
@@ -62,7 +62,8 @@ CutFlowSvc::initialize()
 
 
 CutIdentifier CutFlowSvc::registerFilter( const std::string& name,
-                                          const std::string& description )
+                                          const std::string& description,
+                                          bool nominalOnly )
 {
   ATH_MSG_DEBUG("Registering filter with name '" << name << "' and description '" << description << "'");
 
@@ -79,16 +80,20 @@ CutIdentifier CutFlowSvc::registerFilter( const std::string& name,
   for (xAOD::CutBookkeeper* cbk : *container) {
     if (newCbk->isEqualTo(cbk)) {
       ATH_MSG_DEBUG("The CutBookkeeper with name '" << name << "' already exists"
-                    << " and has cutID " << cbk->uniqueIdentifier() << "... Not adding!" );
+                    << " and has CutID " << cbk->uniqueIdentifier() << "... Not adding!" );
       // Return the existing cut ID
       return cbk->uniqueIdentifier();
     }
   }
 
   // If it is a new CutBookkeeper, add it to the container
-  ATH_MSG_DEBUG("Declaring a new filter with name '" << name << "' and cutID " << cutID );
+  ATH_MSG_DEBUG("Declaring a new filter with name '" << name << "' and CutID " << cutID );
   container->push_back(std::move(newCbk));
 
+  if (nominalOnly) {
+    m_nominalOnlyCuts.emplace(cutID);
+  }
+
   return cutID;
 }
 
@@ -98,17 +103,18 @@ CutIdentifier CutFlowSvc::registerFilter( const std::string& name,
 CutIdentifier CutFlowSvc::registerTopFilter( const std::string& name,
                                              const std::string& description,
                                              unsigned int logic,
-                                             const std::string& outputStream ) 
+                                             const std::string& outputStream,
+                                             bool nominalOnly ) 
 {
   ATH_MSG_DEBUG("Registering top filter with name '" << name << "' and description '" << description << "'"
                 << ", logic=" << logic << ", outputStream=" << outputStream << ")");
 
   // Call the registerFilter method and get the correct CutBookkeeper
   // from the returned cutID
-  CutIdentifier cutID = registerFilter(name, description);
+  CutIdentifier cutID = registerFilter(name, description, nominalOnly);
   xAOD::CutBookkeeper* cbk = getCutBookkeeper(cutID, 0);
   if (cbk == nullptr) {
-    ATH_MSG_ERROR("registerTopFilter: Could not find CutBookkeeper with cutID " << cutID);
+    ATH_MSG_ERROR("Could not find CutBookkeeper with CutID " << cutID);
     return 0;
   }
 
@@ -121,6 +127,37 @@ CutIdentifier CutFlowSvc::registerTopFilter( const std::string& name,
 }
 
 
+CutIdentifier CutFlowSvc::registerCut( const std::string& name,
+                                       const std::string& description,
+                                       CutIdentifier parentCutID,
+                                       bool nominalOnly )
+{
+  ATH_MSG_DEBUG("Registering cut with name '" << name << "', description '" << description
+                << "' and original CutID " << parentCutID);
+
+  // Get the CutBookkeeper of the origin Filter Algorithm/Tool
+  xAOD::CutBookkeeper* parentCbk = getCutBookkeeper(parentCutID, 0);
+  if (parentCbk == nullptr) {
+    ATH_MSG_ERROR("Could not find parent CutBookkeeper with CutID " << parentCutID);
+    return 0;
+  }
+
+  // Call the registerFilter method and get the correct CutBookkeeper
+  // from the returned cutID
+  CutIdentifier cutID = registerFilter(name, description, nominalOnly);
+  xAOD::CutBookkeeper* cbk = getCutBookkeeper(cutID, 0);
+  if (cbk == nullptr) {
+    ATH_MSG_ERROR("Could not find CutBookkeeper with CutID " << cutID);
+    return 0;
+  }
+
+  // Add child to parent
+  parentCbk->addChild(cbk);
+
+  return cutID;
+}
+
+
 void
 CutFlowSvc::setFilterDescription( CutIdentifier cutID,
                                   const std::string& descr )
@@ -137,26 +174,55 @@ CutFlowSvc::setFilterDescription( CutIdentifier cutID,
 }
 
 
+void
+CutFlowSvc::addEvent( CutIdentifier cutID,
+                      const std::vector<float>& weights )
+{
+  if (weights.size() != m_containers.size()) {
+    ATH_MSG_ERROR("Inconsistent weights and variation sizes " << weights.size() << " and " << m_containers.size());
+    return;
+  }
+
+  for (size_t i = 0; i < m_containers.size(); ++i) {
+    addEvent(cutID, i, weights[i]);
+  }
+}
+
 
 void
-CutFlowSvc::addEvent( CutIdentifier cutID, double weight)
+CutFlowSvc::addEvent( CutIdentifier cutID,
+                      double weight )
 {
-  ATH_MSG_VERBOSE("Adding event with weight " << weight << " to cut " << cutID);
+  if (m_nominalOnlyCuts.count(cutID) == 1) {
+    addEvent(cutID, 0, weight);
+    return;
+  }
 
+  for (size_t i = 0; i < m_containers.size(); ++i) {
+    addEvent(cutID, i, weight);
+  }
+}
+
+
+
+void
+CutFlowSvc::addEvent( CutIdentifier cutID,
+                      size_t index,
+                      double weight )
+{
   std::lock_guard<std::recursive_mutex> lock(m_addEventMutex);
 
-  xAOD::CutBookkeeper* cbk = getCutBookkeeper(cutID, 0);
+  ATH_MSG_VERBOSE("Adding event with weight " << weight << " to cut " << cutID << " for variation " << index);
+
+  xAOD::CutBookkeeper* cbk = getCutBookkeeper(cutID, index);
   if (cbk == nullptr) {
-    ATH_MSG_ERROR("Could not find CutBookkeeper for CutID " << cutID);
+    ATH_MSG_ERROR("Could not find CutBookkeeper for CutID " << cutID << " and variation " << index);
     return;
   }
 
-  ATH_MSG_VERBOSE( "addEvent: have cutID " << cutID
-                   << " and CutBookkeeper name " << cbk->name() );
   cbk->addNAcceptedEvents(1);
   cbk->addSumOfEventWeights(weight);
   cbk->addSumOfEventWeightsSquared(weight*weight);
-  return;
 }
 
 
@@ -294,6 +360,10 @@ const CutBookkeepersLocalCache& CutFlowSvc::getCutBookkeepers() const
 xAOD::CutBookkeeper* CutFlowSvc::getCutBookkeeper(const CutIdentifier cutID,
                                                   size_t index) const
 {
+  if (index >= m_containers.size()) {
+    return nullptr;
+  }
+
   for (xAOD::CutBookkeeper* cbk : *m_containers.at(index)) {
     if (cbk->uniqueIdentifier() == cutID) {
       return cbk;
diff --git a/Event/EventBookkeeperTools/Root/FilterReporter.cxx b/Event/EventBookkeeperTools/Root/FilterReporter.cxx
index 48d69f637a890f4324c0889abd46882b646927eb..c4a60f1243de6d8487e5da986e7aa698261c3980 100644
--- a/Event/EventBookkeeperTools/Root/FilterReporter.cxx
+++ b/Event/EventBookkeeperTools/Root/FilterReporter.cxx
@@ -27,6 +27,7 @@ FilterReporter (FilterReporterParams& val_params,
                 bool val_passedDefault)
   : m_params (val_params)
   , m_passed (val_passedDefault)
+  , m_eventContext (&Gaudi::Hive::currentContext())
 {
   if (!m_params.m_isInitialized)
   {
@@ -55,10 +56,6 @@ FilterReporter (const FilterReporterParams& val_params,
 FilterReporter ::
 ~FilterReporter () noexcept
 {
-#ifndef XAOD_STANDALONE
-  if (m_eventContext == nullptr)
-    m_eventContext = &Gaudi::Hive::currentContext();
-#endif
   m_params.m_setFilterPassed (m_passed, m_eventContext);
 
   if (m_passed)
@@ -68,14 +65,13 @@ FilterReporter ::
 #ifndef XAOD_STANDALONE
   if (m_passed && m_params.m_cutID != 0)
   {
-    double weight{1.0};
-
     SG::ReadHandle<xAOD::EventInfo> evtInfo (m_params.m_eventInfoKey, *m_eventContext);
     // Only try to access the mcEventWeight if we are running on Monte Carlo
     if (evtInfo.isValid() && evtInfo->eventType(xAOD::EventInfo::IS_SIMULATION)) {
-      weight = evtInfo->mcEventWeight();
+      m_params.m_cutFlowSvc->addEvent (m_params.m_cutID, evtInfo->mcEventWeights());
+    } else {
+      m_params.m_cutFlowSvc->addEvent (m_params.m_cutID, 1.0);
     }
-    m_params.m_cutFlowSvc->addEvent (m_params.m_cutID, weight);
   }
 #endif
 }
diff --git a/Event/EventBookkeeperTools/Root/FilterReporterParams.cxx b/Event/EventBookkeeperTools/Root/FilterReporterParams.cxx
index 07d5c0a69917103589af7b1536d8973ae8a55191..5de8580237a674547700d21869b83bb22c4f4e1c 100644
--- a/Event/EventBookkeeperTools/Root/FilterReporterParams.cxx
+++ b/Event/EventBookkeeperTools/Root/FilterReporterParams.cxx
@@ -37,7 +37,7 @@ initialize (bool enabled)
   {
     ANA_CHECK (m_cutFlowSvc.retrieve());
 
-    m_cutID = m_cutFlowSvc->registerFilter (m_filterKey, m_filterDescription);
+    m_cutID = m_cutFlowSvc->registerFilter (m_filterKey, m_filterDescription, false);
     if (m_cutID == 0)
     {
       ANA_MSG_ERROR ("problem registering myself with the CutFlowSvc");
diff --git a/Event/EventBookkeeperTools/python/CutFlowHelpers.py b/Event/EventBookkeeperTools/python/CutFlowHelpers.py
index dcef71543bda4465b81759d79badbb5adf0b7f7b..deda3827fb6412372315f6582181ecc818152dbf 100644
--- a/Event/EventBookkeeperTools/python/CutFlowHelpers.py
+++ b/Event/EventBookkeeperTools/python/CutFlowHelpers.py
@@ -71,7 +71,7 @@ def CreateCutFlowSvc( svcName="CutFlowSvc", seq=None, addMetaDataToAllOutputFile
         seq = CfgMgr.AthSequencer("AthAlgSeq")
         pass
 
-    # First of all, schedule EventCounterAlg
+    # First of all, schedule AllExecutedEventsCounterAlg
     if not hasattr(seq,"AllExecutedEvents"):
         if not seq.isLocked():
             # Need to schedule it after the xAODMaker::EventInfoCnvAlg such that xAOD::EventInfo is present
@@ -82,11 +82,11 @@ def CreateCutFlowSvc( svcName="CutFlowSvc", seq=None, addMetaDataToAllOutputFile
                     if alg.getName() == "xAODMaker::EventInfoCnvAlg": break
                     pass
                 pass
-            msg.debug("Adding EventCounterAlg with name AllExecutedEvents to sequence with name %s at position %i", seq.getName(), index)
-            seq.insert( index, CfgMgr.EventCounterAlg("AllExecutedEvents") )
+            msg.debug("Adding AllExecutedEventsCounterAlg with name AllExecutedEvents to sequence with name %s at position %i", seq.getName(), index)
+            seq.insert( index, CfgMgr.AllExecutedEventsCounterAlg("AllExecutedEvents") )
             pass
         else :
-            msg.info("Could NOT add EventCounterAlg with name AllExecutedEvents to locked sequence with name %s", seq.getName())
+            msg.info("Could NOT add AllExecutedEventsCounterAlg with name AllExecutedEvents to locked sequence with name %s", seq.getName())
             pass
         pass
 
@@ -96,10 +96,10 @@ def CreateCutFlowSvc( svcName="CutFlowSvc", seq=None, addMetaDataToAllOutputFile
         from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
         # Explicitely add file metadata from input and from transient store,
         # but only the ones that we always create.
-        MSMgr.AddMetaDataItemToAllStreams( "xAOD::CutBookkeeperContainer#"+primary_name )
-        MSMgr.AddMetaDataItemToAllStreams( "xAOD::CutBookkeeperAuxContainer#"+primary_name+"Aux.*" )
-        MSMgr.AddMetaDataItemToAllStreams( "xAOD::CutBookkeeperContainer#Incomplete"+primary_name )
-        MSMgr.AddMetaDataItemToAllStreams( "xAOD::CutBookkeeperAuxContainer#Incomplete"+primary_name+"Aux.*" )
+        MSMgr.AddMetaDataItemToAllStreams( "xAOD::CutBookkeeperContainer#"+primary_name+"*" )
+        MSMgr.AddMetaDataItemToAllStreams( "xAOD::CutBookkeeperAuxContainer#"+primary_name+"*Aux.*" )
+        MSMgr.AddMetaDataItemToAllStreams( "xAOD::CutBookkeeperContainer#Incomplete"+primary_name+"*" )
+        MSMgr.AddMetaDataItemToAllStreams( "xAOD::CutBookkeeperAuxContainer#Incomplete"+primary_name+"*Aux.*" )
         pass
 
     return
diff --git a/Event/EventBookkeeperTools/python/EventBookkeeperToolsConfig.py b/Event/EventBookkeeperTools/python/EventBookkeeperToolsConfig.py
index 0465d1f5b3cf36371b4df6340a5489d4c2cf4db5..af6472f8988b2089119557d08cb0786530da6f44 100644
--- a/Event/EventBookkeeperTools/python/EventBookkeeperToolsConfig.py
+++ b/Event/EventBookkeeperTools/python/EventBookkeeperToolsConfig.py
@@ -40,8 +40,8 @@ def CutFlowSvcCfg(flags):
 def CutFlowOutputList(flags, base_name='CutBookkeepers'):
     """CutFlow output metadata list"""
     return [
-        'xAOD::CutBookkeeperContainer#' + base_name,
-        'xAOD::CutBookkeeperAuxContainer#' + base_name + 'Aux.*',
-        'xAOD::CutBookkeeperContainer#Incomplete' + base_name,
-        'xAOD::CutBookkeeperAuxContainer#Incomplete' + base_name + 'Aux.*'
+        'xAOD::CutBookkeeperContainer#' + base_name + '*',
+        'xAOD::CutBookkeeperAuxContainer#' + base_name + '*Aux.*',
+        'xAOD::CutBookkeeperContainer#Incomplete' + base_name + '*',
+        'xAOD::CutBookkeeperAuxContainer#Incomplete' + base_name + '*Aux.*'
     ]
diff --git a/Event/EventBookkeeperTools/src/AllExecutedEventsCounterAlg.cxx b/Event/EventBookkeeperTools/src/AllExecutedEventsCounterAlg.cxx
index 4cacb8a86a95a06487ad73112daa19a4b79d522d..79a14ab31406c7a84810be18121449126d1111b8 100644
--- a/Event/EventBookkeeperTools/src/AllExecutedEventsCounterAlg.cxx
+++ b/Event/EventBookkeeperTools/src/AllExecutedEventsCounterAlg.cxx
@@ -25,9 +25,10 @@ StatusCode AllExecutedEventsCounterAlg::initialize()
   ATH_CHECK(m_filterParams.initialize());
 
   m_filterParams.cutFlowSvc()->registerTopFilter(m_filterParams.key(),
-                                              "Number of processed events before any cut",
-                                              xAOD::CutBookkeeper::CutLogic::ALLEVENTSPROCESSED,
-                                              "AllStreams");
+                                                 "Number of processed events before any cut",
+                                                 xAOD::CutBookkeeper::CutLogic::ALLEVENTSPROCESSED,
+                                                 "AllStreams",
+                                                 false);
 
   return StatusCode::SUCCESS;
 }
diff --git a/Event/EventBookkeeperTools/src/EventCounterAlg.cxx b/Event/EventBookkeeperTools/src/EventCounterAlg.cxx
deleted file mode 100644
index 8dc1d40a930cd9c95847332631008b53d5aff5fa..0000000000000000000000000000000000000000
--- a/Event/EventBookkeeperTools/src/EventCounterAlg.cxx
+++ /dev/null
@@ -1,133 +0,0 @@
-///////////////////////// -*- C++ -*- /////////////////////////////
-
-/*
-  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
-*/
-
-// EventCounterAlg.cxx
-// Implementation file for class EventCounterAlg
-// Author: S.Binet<binet@cern.ch>
-///////////////////////////////////////////////////////////////////
-
-// EventBookkeeperTools includes
-#include "EventCounterAlg.h"
-
-// STL includes
-//#include <stdio.h>
-//#include <stdlib.h>
-//#include <printf.h>
-#include <iostream>
-
-// EDM includes
-#include "xAODCutFlow/CutBookkeeper.h"
-#include "xAODEventInfo/EventInfo.h"
-#include "StoreGate/ReadHandle.h"
-
-
-
-///////////////////////////////////////////////////////////////////
-// Public methods:
-///////////////////////////////////////////////////////////////////
-
-// Constructors
-////////////////
-EventCounterAlg::EventCounterAlg( const std::string& name,
-                                  ISvcLocator* pSvcLocator ) :
-  ::AthFilterAlgorithm( name, pSvcLocator ),
-  m_trackOtherMCWeights(false),
-  m_eventsProcessed(0),
-  m_mcCutIDs()
-{
-  //
-  // Property declaration
-  //
-  declareProperty( "BookkeepOtherMCEventWeights", m_trackOtherMCWeights=true,
-                   "If true, the non-nominal MC event weights will be bookkept as well" );
-}
-
-
-
-// Destructor
-///////////////
-EventCounterAlg::~EventCounterAlg()
-{}
-
-
-
-// Athena Algorithm's Hooks
-////////////////////////////
-StatusCode EventCounterAlg::initialize()
-{
-  ATH_MSG_DEBUG ("Initializing " << this->name() << "...");
-
-  cutFlowSvc()->registerTopFilter( this->name(),
-                                   "Number of processed events before any cut",
-                                   xAOD::CutBookkeeper::CutLogic::ALLEVENTSPROCESSED,
-                                   "AllStreams");
-
-  return StatusCode::SUCCESS;
-}
-
-
-
-StatusCode EventCounterAlg::finalize()
-{
-  ATH_MSG_DEBUG ("Finalizing " << this->name() << "...");
-  return StatusCode::SUCCESS;
-}
-
-
-
-StatusCode EventCounterAlg::execute()
-{
-  const EventContext& ctx = Gaudi::Hive::currentContext();
-  ATH_MSG_VERBOSE ("Executing " << this->name() << "...");
-
-  setFilterPassed(true);
-
-  // Update also the other counters for the non-nominal MC weights
-  if (m_trackOtherMCWeights) {
-    // Get the EventInfo object
-    SG::ReadHandle<xAOD::EventInfo> evtInfo (eventInfoKey(), ctx);
-    // Only try to access the mcEventWeight is we are running on Monte Carlo, duhhh!
-    if ( !(evtInfo->eventType(xAOD::EventInfo::IS_SIMULATION)) ) {
-      ATH_MSG_DEBUG("We are not running on simulation and thus, nothing to be done here");
-      m_trackOtherMCWeights = false;
-      return StatusCode::SUCCESS;
-    }
-
-    // Get all MC event weights
-    const std::vector<float>& mcWeights = evtInfo->mcEventWeights();
-
-    // Set up everything during the first event
-    if ( m_eventsProcessed == 0 ){
-      const std::size_t nNonNominalMCWeight = mcWeights.size() - 1;
-      m_mcCutIDs.reserve(nNonNominalMCWeight);
-      for ( std::size_t i=1; i<mcWeights.size(); ++i ) {
-        std::stringstream sstm;
-        sstm << this->name() << "_NonNominalMCWeight_" << i;
-        const std::string cutName = sstm.str();
-        std::stringstream sstm2;
-        sstm2 << "non-nominal MC event weight number " << i;
-        const std::string& cutDescription = sstm2.str();
-        CutIdentifier cutID = cutFlowSvc()->registerTopFilter( cutName,
-                                                               cutDescription,
-                                                               xAOD::CutBookkeeper::CutLogic::ALLEVENTSPROCESSED,
-                                                               "AllStreams" );
-        m_mcCutIDs.push_back(cutID);
-      }
-    }
-
-    // Increment the non-nominal MC event weight counters
-    for ( std::size_t i=0; i<m_mcCutIDs.size(); ++i) {
-      const double weight = static_cast<double>(mcWeights[i+1]);
-      const CutIdentifier cutID = m_mcCutIDs[i];
-      cutFlowSvc()->addEvent( cutID, weight );
-    }
-
-    // Increment the event counter
-    m_eventsProcessed += 1;
-  }
-
-  return StatusCode::SUCCESS;
-}
diff --git a/Event/EventBookkeeperTools/src/EventCounterAlg.h b/Event/EventBookkeeperTools/src/EventCounterAlg.h
deleted file mode 100644
index e489cf7ba4959e808fb68c5f7c5b8ff169aa5e0b..0000000000000000000000000000000000000000
--- a/Event/EventBookkeeperTools/src/EventCounterAlg.h
+++ /dev/null
@@ -1,83 +0,0 @@
-///////////////////////// -*- C++ -*- /////////////////////////////
-
-/*
-  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
-*/
-
-// EventCounterAlg.h
-// Header file for class EventCounterAlg
-// Author: S.Binet<binet@cern.ch>
-///////////////////////////////////////////////////////////////////
-#ifndef EVENTBOOKKEEPERTOOLS_EVENTCOUNTERALG_H
-#define EVENTBOOKKEEPERTOOLS_EVENTCOUNTERALG_H 1
-
-// STL includes
-#include <string>
-#include <vector>
-
-// FrameWork includes
-#include "AthenaBaseComps/AthFilterAlgorithm.h"
-#include "StoreGate/ReadHandleKey.h"
-#include "xAODEventInfo/EventInfo.h"
-
-
-class EventCounterAlg
-  : public ::AthFilterAlgorithm
-{
-
-  ///////////////////////////////////////////////////////////////////
-  // Public methods:
-  ///////////////////////////////////////////////////////////////////
- public:
-
-  // Copy constructor:
-
-  /// Constructor with parameters:
-  EventCounterAlg( const std::string& name, ISvcLocator* pSvcLocator );
-
-  /// Destructor:
-  virtual ~EventCounterAlg();
-
-  // Assignment operator:
-  //EventCounterAlg &operator=(const EventCounterAlg &alg);
-
-  // Athena algorithm's Hooks
-  virtual StatusCode  initialize() override;
-  virtual StatusCode  execute() override;
-  virtual StatusCode  finalize() override;
-
-  ///////////////////////////////////////////////////////////////////
-  // Const methods:
-  ///////////////////////////////////////////////////////////////////
-
-  ///////////////////////////////////////////////////////////////////
-  // Non-const methods:
-  ///////////////////////////////////////////////////////////////////
-
-  ///////////////////////////////////////////////////////////////////
-  // Private data:
-  ///////////////////////////////////////////////////////////////////
- private:
-
-  /// Default constructor:
-  EventCounterAlg();
-
-  /// Property to set if all MC event-weights, including the non-nominal ones, should be tracked
-  bool m_trackOtherMCWeights;
-
-  /// An event counter
-  unsigned long m_eventsProcessed;
-
-  /// Keep a vector of all cutIDs for the non-nominal MC event weights
-  std::vector<CutIdentifier> m_mcCutIDs;
-};
-
-// I/O operators
-//////////////////////
-
-///////////////////////////////////////////////////////////////////
-// Inline methods:
-///////////////////////////////////////////////////////////////////
-
-
-#endif //> !EVENTBOOKKEEPERTOOLS_EVENTCOUNTERALG_H
diff --git a/Event/EventBookkeeperTools/src/components/EventBookkeeperTools_entries.cxx b/Event/EventBookkeeperTools/src/components/EventBookkeeperTools_entries.cxx
index 464b2a0f96de15e774fd72a97bf6d9f1643a5bc3..44daab678e599355d8c1ca0281bcef7f3dd99b5d 100644
--- a/Event/EventBookkeeperTools/src/components/EventBookkeeperTools_entries.cxx
+++ b/Event/EventBookkeeperTools/src/components/EventBookkeeperTools_entries.cxx
@@ -3,12 +3,10 @@
 #include <EventBookkeeperTools/CutFlowSvc.h>
 
 #include "../AllExecutedEventsCounterAlg.h"
-#include "../EventCounterAlg.h"
 #include "../TestFilterReentrantAlg.h"
 
 DECLARE_COMPONENT( AllExecutedEventsCounterAlg )
 DECLARE_COMPONENT( BookkeeperDumperTool )
 DECLARE_COMPONENT( BookkeeperTool )
 DECLARE_COMPONENT( CutFlowSvc )
-DECLARE_COMPONENT( EventCounterAlg )
 DECLARE_COMPONENT( TestFilterReentrantAlg )
diff --git a/PhysicsAnalysis/Algorithms/SystematicsHandles/Root/SysFilterReporterParams.cxx b/PhysicsAnalysis/Algorithms/SystematicsHandles/Root/SysFilterReporterParams.cxx
index 3daac19f9e8efa948e7f58b0559a05e7aaf4534a..415dedf1bb0ef7d5dc468c54947bee5a2fab4689 100644
--- a/PhysicsAnalysis/Algorithms/SystematicsHandles/Root/SysFilterReporterParams.cxx
+++ b/PhysicsAnalysis/Algorithms/SystematicsHandles/Root/SysFilterReporterParams.cxx
@@ -39,7 +39,7 @@ namespace CP
     if (!m_cutFlowSvc.empty())
     {
       ANA_CHECK (m_cutFlowSvc.retrieve());
-      m_cutID = m_cutFlowSvc->registerFilter (m_cutFlowSvc.parentName(), m_filterDescription + " (nominal only)");
+      m_cutID = m_cutFlowSvc->registerFilter (m_cutFlowSvc.parentName(), m_filterDescription + " (nominal only)", false);
       if (m_cutID == 0)
       {
         ANA_MSG_ERROR ("problem registering myself with cutflow-svc");
diff --git a/PhysicsAnalysis/AnalysisCommon/ReweightUtils/src/SumOfWeightsAlg.cxx b/PhysicsAnalysis/AnalysisCommon/ReweightUtils/src/SumOfWeightsAlg.cxx
index 5437a38f071fc186b9139c7a53ef780474c1c87f..c8c47db50d77787174990c1371be6c243a0b561f 100644
--- a/PhysicsAnalysis/AnalysisCommon/ReweightUtils/src/SumOfWeightsAlg.cxx
+++ b/PhysicsAnalysis/AnalysisCommon/ReweightUtils/src/SumOfWeightsAlg.cxx
@@ -51,7 +51,8 @@ StatusCode SumOfWeightsAlg::initialize() {
     CutIdentifier cID = cutFlowSvc()->registerTopFilter( toolName,
                                                          toolName, // description (can be improved FIXME)
                                                          xAOD::CutBookkeeper::CutLogic::ALLEVENTSPROCESSED,
-                                                         "AllStreams");
+                                                         "AllStreams",
+                                                         true);
     m_cutIDs.push_back(cID);
   }
 
diff --git a/Reconstruction/RecExample/RecExCommon/share/AnalysisCommon_topOptions.py b/Reconstruction/RecExample/RecExCommon/share/AnalysisCommon_topOptions.py
index af8117f22ff0efa77531b03f773fdc4844790dd8..5b4dc9e81d2c2e248273b8f8a7c82e269936bc39 100644
--- a/Reconstruction/RecExample/RecExCommon/share/AnalysisCommon_topOptions.py
+++ b/Reconstruction/RecExample/RecExCommon/share/AnalysisCommon_topOptions.py
@@ -377,10 +377,6 @@ if rec.doDPD() and (rec.DPDMakerScripts()!=[] or rec.doDPD.passThroughMode):
         #    pass
         pass
 
-    # #First of all, schedule EventCounterAlg
-    # from EventBookkeeperTools.EventCounterAlg import EventCounterAlg
-    # topSequence+=EventCounterAlg("AllExecutedEvents")
-
     #Then include all requested DPD makers
     logAnaCommon_topOptions.debug( "Content of rec.DPDMakerSkripts = %s", rec.DPDMakerScripts() )
     for DPDMaker in rec.DPDMakerScripts():
diff --git a/Reconstruction/RecExample/RecExCommon/share/RecExCommon_topOptions.py b/Reconstruction/RecExample/RecExCommon/share/RecExCommon_topOptions.py
index f38fbfeedb7a990d8c158f3f9b73a32bfe5bf232..c3cbe33b32d8d8a993ea7b1727df2c52a2d0cd4b 100644
--- a/Reconstruction/RecExample/RecExCommon/share/RecExCommon_topOptions.py
+++ b/Reconstruction/RecExample/RecExCommon/share/RecExCommon_topOptions.py
@@ -981,7 +981,11 @@ if rec.doTrigger and rec.doTriggerFilter() and globalflags.DataSource() == 'data
 ### seq will be our filter sequence
         from AthenaCommon.AlgSequence import AthSequencer
         seq=AthSequencer("AthMasterSeq")
-        seq+=CfgMgr.EventCounterAlg("AllExecutedEventsAthMasterSeq")
+
+        from EventBookkeeperTools.CutFlowHelpers import CreateCutFlowSvc
+        logRecExCommon_topOptions.debug("Calling CreateCutFlowSvc")
+        CreateCutFlowSvc( svcName="CutFlowSvc", seq=seq, addMetaDataToAllOutputFiles=True )
+
         seq+=topSequence.RoIBResultToxAOD
         seq+=topSequence.TrigBSExtraction
         seq+=topSequence.TrigDecMaker