diff --git a/objectstore/BackendFactory.cpp b/objectstore/BackendFactory.cpp
index 7e98d21893d24785e5332bd1c63e66c4878a8de7..f96dae143b2b45cae567141755e5d8b4b1c71fb6 100644
--- a/objectstore/BackendFactory.cpp
+++ b/objectstore/BackendFactory.cpp
@@ -23,7 +23,7 @@
 #include "common/utils/utils.hpp"
 #include "common/utils/Regex.hpp"
 
-auto cta::objectstore::BackendFactory::createBackend(const std::string& URL)
+auto cta::objectstore::BackendFactory::createBackend(const std::string& URL, log::Logger & logger)
   -> std::unique_ptr<Backend> {
   utils::Regex fileRe("^file://(.*)$"),
       radosRe("^rados://([^@]+)@([^:]+)(|:(.+))$");
@@ -39,9 +39,9 @@ auto cta::objectstore::BackendFactory::createBackend(const std::string& URL)
     if (regexResult.size() != 5 && regexResult.size() != 4)
       throw cta::exception::Exception("In BackendFactory::createBackend(): unexpected number of matches in regex");
     if (regexResult.size() == 5)
-      return std::unique_ptr<Backend>(new BackendRados(regexResult[1], regexResult[2], regexResult[4]));
+      return std::unique_ptr<Backend>(new BackendRados(logger, regexResult[1], regexResult[2], regexResult[4]));
     else
-      return std::unique_ptr<Backend>(new BackendRados(regexResult[1], regexResult[2]));
+      return std::unique_ptr<Backend>(new BackendRados(logger, regexResult[1], regexResult[2]));
   }
   // Fall back to a file URL if all failed
   return std::unique_ptr<Backend>(new BackendVFS(URL));
diff --git a/objectstore/BackendFactory.hpp b/objectstore/BackendFactory.hpp
index ecb7ebcf152bad1d70b109033367f18235d9c2ca..d4ac004ded9524bc6da44d740a711fa7498a22bd 100644
--- a/objectstore/BackendFactory.hpp
+++ b/objectstore/BackendFactory.hpp
@@ -19,11 +19,12 @@
 #pragma once
 
 #include "Backend.hpp"
+#include "common/log/Logger.hpp"
 #include <memory>
 
 namespace cta { namespace objectstore {
   class BackendFactory {
   public:
-    static std::unique_ptr<Backend> createBackend(const std::string & URL);
+    static std::unique_ptr<Backend> createBackend(const std::string & URL, log::Logger & logger);
   };
 }}
\ No newline at end of file
diff --git a/objectstore/BackendRados.cpp b/objectstore/BackendRados.cpp
index 3a50e9ec2988bd5c9a0c9bb672239926240a5f1d..a9316c6f45572202a338905a22dff9d910cedbb2 100644
--- a/objectstore/BackendRados.cpp
+++ b/objectstore/BackendRados.cpp
@@ -80,23 +80,53 @@ namespace cta { namespace objectstore {
 
 cta::threading::Mutex BackendRados::RadosTimeoutLogger::g_mutex;
 
-BackendRados::BackendRados(const std::string & userId, const std::string & pool, const std::string &radosNameSpace) :
+BackendRados::BackendRados(log::Logger & logger, const std::string & userId, const std::string & pool,
+  const std::string &radosNameSpace) :
 m_user(userId), m_pool(pool), m_namespace(radosNameSpace), m_cluster(), m_radosCtx() {
   cta::exception::Errnum::throwOnReturnedErrno(-m_cluster.init(userId.c_str()),
       "In ObjectStoreRados::ObjectStoreRados, failed to m_cluster.init");
+  bool contextSet=false;
   try {
+    RadosTimeoutLogger rtl;
     cta::exception::Errnum::throwOnReturnedErrno(-m_cluster.conf_read_file(NULL),
         "In ObjectStoreRados::ObjectStoreRados, failed to m_cluster.conf_read_file");
+    rtl.logIfNeeded("In BackendRados::BackendRados(): m_cluster.conf_read_file()", "no object");
+    rtl.reset();
     cta::exception::Errnum::throwOnReturnedErrno(-m_cluster.conf_parse_env(NULL),
         "In ObjectStoreRados::ObjectStoreRados, failed to m_cluster.conf_parse_env");
+    rtl.logIfNeeded("In BackendRados::BackendRados(): m_cluster.conf_parse_env()", "no object");
+    rtl.reset();
     cta::exception::Errnum::throwOnReturnedErrno(-m_cluster.connect(),
         "In ObjectStoreRados::ObjectStoreRados, failed to m_cluster.connect");
+    rtl.logIfNeeded("In BackendRados::BackendRados(): m_cluster.connect()", "no object");
+    rtl.reset();
     cta::exception::Errnum::throwOnReturnedErrno(-m_cluster.ioctx_create(pool.c_str(), m_radosCtx),
         "In ObjectStoreRados::ObjectStoreRados, failed to m_cluster.ioctx_create");
+    rtl.logIfNeeded("In BackendRados::BackendRados(): m_cluster.ioctx_create()", "no object");
+    contextSet=true;
     // An empty string also sets the namespace to default so no need to filter. This function does not fail.
     m_radosCtx.set_namespace(radosNameSpace);
+    // Create the thread pool. One thread per CPU hardware thread.
+    for (size_t i=0; i<std::thread::hardware_concurrency(); i++) {
+      RadosWorkerThreadAndContext * rwtac = new RadosWorkerThreadAndContext(m_cluster, pool, radosNameSpace, i, logger);
+      m_threads.push_back(rwtac);
+      m_threads.back()->start();
+    }
   } catch (...) {
+    for (size_t i=0; i<m_threads.size(); i++) m_JobQueue.push(nullptr);
+    for (auto &t: m_threads) {
+      if (t) t->wait();
+      delete t;
+    }
+    if (contextSet) 
+    {
+      RadosTimeoutLogger rtl;
+      m_radosCtx.close();
+      rtl.logIfNeeded("In BackendRados::BackendRados(): m_radosCtx.close()", "no object");
+    }
+    RadosTimeoutLogger rtl;
     m_cluster.shutdown();
+    rtl.logIfNeeded("In BackendRados::BackendRados(): m_cluster.shutdown()", "no object");
     throw;
   }
 }
@@ -504,6 +534,28 @@ BackendRados::ScopedLock* BackendRados::lockShared(std::string name, uint64_t ti
   return ret.release();
 }
 
+BackendRados::RadosWorkerThreadAndContext::RadosWorkerThreadAndContext(librados::Rados& cluster, 
+  const std::string & pool, const std::string& radosNameSpace, int threadID, log::Logger & logger): 
+  m_threadID(threadID), m_lc(logger) {
+  RadosTimeoutLogger rtl;
+  cta::exception::Errnum::throwOnReturnedErrno(-cluster.ioctx_create(pool.c_str(), m_radosCtx),
+      "In RadosWorkerThreadAndContext::RadosWorkerThreadAndContext, failed to cluster.ioctx_create");
+  rtl.logIfNeeded("In RadosWorkerThreadAndContext::RadosWorkerThreadAndContext(): ", "no object");
+  // An empty string also sets the namespace to default so no need to filter. This function does not fail.
+  m_radosCtx.set_namespace(radosNameSpace);
+}
+
+BackendRados::RadosWorkerThreadAndContext::~RadosWorkerThreadAndContext() {
+  RadosTimeoutLogger rtl;
+  m_radosCtx.close();
+  rtl.logIfNeeded("In RadosWorkerThreadAndContext::~RadosWorkerThreadAndContext(): m_radosCtx.close()", "no object");
+}
+
+void BackendRados::RadosWorkerThreadAndContext::run() {
+  
+}
+
+
 Backend::AsyncUpdater* BackendRados::asyncUpdate(const std::string & name, std::function <std::string(const std::string &)> & update)
 {
   return new AsyncUpdater(*this, name, update);
diff --git a/objectstore/BackendRados.hpp b/objectstore/BackendRados.hpp
index e52ee4cd59518be858bb830eb34c517eecee5366..e0fb508c6146ab4b3e1e44268f7c8f722fd0c77f 100644
--- a/objectstore/BackendRados.hpp
+++ b/objectstore/BackendRados.hpp
@@ -21,6 +21,9 @@
 #include "Backend.hpp"
 #include "rados/librados.hpp"
 #include "common/threading/Mutex.hpp"
+#include "common/threading/BlockingQueue.hpp"
+#include "common/log/Logger.hpp"
+#include "common/log/LogContext.hpp"
 #include <future>
 
 // RADOS_LOCKING can be NOTIFY or BACKOFF
@@ -57,7 +60,7 @@ public:
    * @param userId
    * @param pool
    */
-  BackendRados(const std::string & userId, const std::string & pool, const std::string &radosNameSpace = "");
+  BackendRados(log::Logger & logger, const std::string & userId, const std::string & pool, const std::string &radosNameSpace = "");
   ~BackendRados() override;
   std::string user() {
     return m_user;
@@ -183,6 +186,42 @@ private:
     uint64_t m_watchHandle;
   };
   
+private:
+  /**
+   * Base class for jobs handled by the thread-and-context pool.
+   */
+  class AsyncJob {
+    virtual void execute(librados::IoCtx & context)=0;
+    virtual ~AsyncJob() {}
+  };
+  
+  /**
+   * The queue for the thread-and-context pool.
+   */
+  cta::threading::BlockingQueue<AsyncJob *> m_JobQueue;
+  
+  /**
+   * The class for the worker threads
+   */
+  class RadosWorkerThreadAndContext: private cta::threading::Thread {
+  public:
+    RadosWorkerThreadAndContext(librados::Rados & cluster, const std::string & pool, const std::string & radosNameSpace, 
+      int threadID, log::Logger & logger);
+    virtual ~RadosWorkerThreadAndContext();
+    void start() { cta::threading::Thread::start(); }
+    void wait() { cta::threading::Thread::wait(); }
+  private:
+    librados::IoCtx m_radosCtx;
+    const int m_threadID;
+    log::LogContext m_lc;
+    void run() override;
+  };
+  
+  /**
+   * The container for the threads
+   */
+  std::vector<RadosWorkerThreadAndContext *> m_threads;
+  
 public:
   /**
    * A class following up the check existence-lock-fetch-update-write-unlock. Constructor implicitly
diff --git a/objectstore/cta-objectstore-collect-orphaned-object.cpp b/objectstore/cta-objectstore-collect-orphaned-object.cpp
index e3e2c85bd0203f568ce62e7d34d082d66469965e..a6188019a39543caa211c9ed14fdeaaf93500242 100644
--- a/objectstore/cta-objectstore-collect-orphaned-object.cpp
+++ b/objectstore/cta-objectstore-collect-orphaned-object.cpp
@@ -44,7 +44,7 @@ int main(int argc, char ** argv) {
     cta::log::LogContext lc(sl);
     std::string objectName;
     if (4 == argc) {
-      be.reset(cta::objectstore::BackendFactory::createBackend(argv[1]).release());
+      be.reset(cta::objectstore::BackendFactory::createBackend(argv[1], sl).release());
       const cta::rdbms::Login catalogueLogin = cta::rdbms::Login::parseFile(argv[2]);
       const uint64_t nbConns = 1;
       const uint64_t nbArchiveFileListingConns = 0;
@@ -52,7 +52,7 @@ int main(int argc, char ** argv) {
       objectName = argv[3];
     } else if (2 == argc) {
       cta::common::Configuration m_ctaConf("/etc/cta/cta-frontend.conf");
-      be = std::move(cta::objectstore::BackendFactory::createBackend(m_ctaConf.getConfEntString("ObjectStore", "BackendPath", nullptr)));
+      be = std::move(cta::objectstore::BackendFactory::createBackend(m_ctaConf.getConfEntString("ObjectStore", "BackendPath", nullptr), sl));
       const cta::rdbms::Login catalogueLogin = cta::rdbms::Login::parseFile("/etc/cta/cta-catalogue.conf");
       const uint64_t nbConns = 1;
       const uint64_t nbArchiveFileListingConns = 0;
diff --git a/objectstore/cta-objectstore-dereference-removed-queues.cpp b/objectstore/cta-objectstore-dereference-removed-queues.cpp
index 560522493c2431fa27e253d4be4e10ada94b1748..5aaeb492869d00d490682468f0dd9bcdaca72de9 100644
--- a/objectstore/cta-objectstore-dereference-removed-queues.cpp
+++ b/objectstore/cta-objectstore-dereference-removed-queues.cpp
@@ -23,6 +23,8 @@
  */
 
 #include "common/Configuration.hpp"
+#include "common/log/StdoutLogger.hpp"
+#include "common/log/LogContext.hpp"
 #include "BackendFactory.hpp"
 #include "BackendVFS.hpp"
 #include "Agent.hpp"
@@ -33,12 +35,13 @@
 
 int main(int argc, char ** argv) {
   try {
+    cta::log::StdoutLogger logger("cta-objectstore-dereference-removed-queues");
     std::unique_ptr<cta::objectstore::Backend> be;
     if (2 == argc) {
-      be.reset(cta::objectstore::BackendFactory::createBackend(argv[1]).release());
+      be.reset(cta::objectstore::BackendFactory::createBackend(argv[1], logger).release());
     } else if (1 == argc) {
       cta::common::Configuration m_ctaConf("/etc/cta/cta-frontend.conf");
-      be = std::move(cta::objectstore::BackendFactory::createBackend(m_ctaConf.getConfEntString("ObjectStore", "BackendPath", nullptr)));
+      be = std::move(cta::objectstore::BackendFactory::createBackend(m_ctaConf.getConfEntString("ObjectStore", "BackendPath", nullptr), logger));
     } else {
       throw std::runtime_error("Wrong number of arguments: expected 0 or 1: [objectstoreURL]");
     }
diff --git a/objectstore/cta-objectstore-dump-object.cpp b/objectstore/cta-objectstore-dump-object.cpp
index 7e3899ef311a39ad22517fa9852359052a48d813..9cce8d42b295c6493f802213904cfd3282ec1e05 100644
--- a/objectstore/cta-objectstore-dump-object.cpp
+++ b/objectstore/cta-objectstore-dump-object.cpp
@@ -24,6 +24,8 @@
 
 #include "common/Configuration.hpp"
 #include "BackendFactory.hpp"
+#include "common/log/DummyLogger.hpp"
+#include "common/log/LogContext.hpp"
 #include "BackendVFS.hpp"
 #include "GenericObject.hpp"
 #include <iostream>
@@ -31,14 +33,15 @@
 
 int main(int argc, char ** argv) {
   try {
+    cta::log::DummyLogger dl("");
     std::unique_ptr<cta::objectstore::Backend> be;
     std::string objectName;
     if (3 == argc) {
-      be.reset(cta::objectstore::BackendFactory::createBackend(argv[1]).release());
+      be.reset(cta::objectstore::BackendFactory::createBackend(argv[1], dl).release());
       objectName = argv[2];
     } else if (2 == argc ){
       cta::common::Configuration m_ctaConf("/etc/cta/cta-frontend.conf");
-      be=std::move(cta::objectstore::BackendFactory::createBackend(m_ctaConf.getConfEntString("ObjectStore", "BackendPath", nullptr)));
+      be=std::move(cta::objectstore::BackendFactory::createBackend(m_ctaConf.getConfEntString("ObjectStore", "BackendPath", nullptr), dl));
       objectName = argv[1];
     } else {
       throw std::runtime_error("Wrong number of arguments: expected 1 or 2: [objectstoreURL] objectname");
diff --git a/objectstore/cta-objectstore-initialize.cpp b/objectstore/cta-objectstore-initialize.cpp
index 9d0d2a206198a91ad4bdb329d8d8f4e7dd52c695..93f2faefa3680e282e92af093b100faa58a15c9c 100644
--- a/objectstore/cta-objectstore-initialize.cpp
+++ b/objectstore/cta-objectstore-initialize.cpp
@@ -33,12 +33,13 @@
 
 int main(int argc, char ** argv) {
   try {
+    cta::log::StdoutLogger logger("cta-objectstore-initialize");
+    cta::log::LogContext lc(logger);
     std::unique_ptr<cta::objectstore::Backend> be;
     if (1 == argc) {
       be.reset(new cta::objectstore::BackendVFS);
-      
     } else if (2 == argc) {
-      be.reset(cta::objectstore::BackendFactory::createBackend(argv[1]).release());
+      be.reset(cta::objectstore::BackendFactory::createBackend(argv[1], logger).release());
     } else {
       throw std::runtime_error("Wrong number of arguments: expected 0 or 1");
     }
@@ -52,12 +53,10 @@ int main(int argc, char ** argv) {
     re.insert();
     cta::objectstore::ScopedExclusiveLock rel(re);
     re.fetch();
-    cta::log::StdoutLogger logger("cta-objectstore-initialize");
     cta::objectstore::AgentReference agr("cta-objectstore-initialize", logger);
     cta::objectstore::Agent ag(agr.getAgentAddress(), *be);
     ag.initialize();
     cta::objectstore::EntryLogSerDeser el("user0", "systemhost", time(NULL));
-    cta::log::LogContext lc(logger);
     re.addOrGetAgentRegisterPointerAndCommit(agr,el, lc);
     rel.release();
     ag.insertAndRegisterSelf(lc);
diff --git a/objectstore/cta-objectstore-list.cpp b/objectstore/cta-objectstore-list.cpp
index e0ddc4e82bdc0615cb2edd2083723fc7ffa51839..f0cb5ac9161017cba3cb68e8f664a077313345a0 100644
--- a/objectstore/cta-objectstore-list.cpp
+++ b/objectstore/cta-objectstore-list.cpp
@@ -25,6 +25,8 @@
 #include "common/Configuration.hpp"
 #include "BackendVFS.hpp"
 #include "BackendFactory.hpp"
+#include "common/log/DummyLogger.hpp"
+#include "common/log/LogContext.hpp"
 #include "RootEntry.hpp"
 #include "Agent.hpp"
 #include <iostream>
@@ -32,12 +34,13 @@
 
 int main(int argc, char ** argv) {
   try {
+    cta::log::DummyLogger dl("");
     std::unique_ptr<cta::objectstore::Backend> be;
     if (1 == argc) {
       cta::common::Configuration m_ctaConf("/etc/cta/cta-frontend.conf");
-      be = std::move(cta::objectstore::BackendFactory::createBackend(m_ctaConf.getConfEntString("ObjectStore", "BackendPath", nullptr)));      
+      be = std::move(cta::objectstore::BackendFactory::createBackend(m_ctaConf.getConfEntString("ObjectStore", "BackendPath", nullptr), dl));      
     } else if (2 == argc) {
-      be.reset(cta::objectstore::BackendFactory::createBackend(argv[1]).release());
+      be.reset(cta::objectstore::BackendFactory::createBackend(argv[1], dl).release());
     } else {
       throw std::runtime_error("Wrong number of arguments: expected 0 or 1: [objectstoreURL]");
     }
diff --git a/objectstore/cta-objectstore-unfollow-agent.cpp b/objectstore/cta-objectstore-unfollow-agent.cpp
index 1a61b3404e6bc88d6a0363d446fda6d7dbef3f95..02482e5f6522156948b5ce683c23f50c22b0fca4 100644
--- a/objectstore/cta-objectstore-unfollow-agent.cpp
+++ b/objectstore/cta-objectstore-unfollow-agent.cpp
@@ -24,6 +24,8 @@
 
 #include "common/Configuration.hpp"
 #include "BackendFactory.hpp"
+#include "common/log/StdoutLogger.hpp"
+#include "common/log/LogContext.hpp"
 #include "BackendVFS.hpp"
 #include "Agent.hpp"
 #include "RootEntry.hpp"
@@ -34,14 +36,15 @@
 
 int main(int argc, char ** argv) {
   try {
+    cta::log::StdoutLogger logger("cta-objectstore-unfollow-agent");
     std::string agentName;
     std::unique_ptr<cta::objectstore::Backend> be;
     if (3 == argc) {
-      be.reset(cta::objectstore::BackendFactory::createBackend(argv[1]).release());
+      be.reset(cta::objectstore::BackendFactory::createBackend(argv[1], logger).release());
       agentName = argv[2];
     } else if (2 == argc) {
       cta::common::Configuration m_ctaConf("/etc/cta/cta-frontend.conf");
-      be=std::move(cta::objectstore::BackendFactory::createBackend(m_ctaConf.getConfEntString("ObjectStore", "BackendPath", nullptr)));
+      be=std::move(cta::objectstore::BackendFactory::createBackend(m_ctaConf.getConfEntString("ObjectStore", "BackendPath", nullptr), logger));
       agentName = argv[1];
     } else {
       throw std::runtime_error("Wrong number of arguments: expected 1 or 2: [objectstoreURL] agentName");
diff --git a/scheduler/OStoreDB/OStoreDBFactory.hpp b/scheduler/OStoreDB/OStoreDBFactory.hpp
index d7fd49501e324eee53c5fbaf02ab505ad7f90497..5579662c32d7fb2f2ded1d9969ec66c8e8cb07fa 100644
--- a/scheduler/OStoreDB/OStoreDBFactory.hpp
+++ b/scheduler/OStoreDB/OStoreDBFactory.hpp
@@ -165,8 +165,8 @@ public:
   }
 
 private:
-  std::unique_ptr <cta::objectstore::Backend> m_backend;
   std::unique_ptr <cta::log::Logger> m_logger;
+  std::unique_ptr <cta::objectstore::Backend> m_backend;
   std::unique_ptr <cta::catalogue::Catalogue> m_catalogue;
   cta::OStoreDB m_OStoreDB;
   objectstore::AgentReference m_agentReference;
@@ -175,7 +175,7 @@ private:
 template <>
 OStoreDBWrapper<cta::objectstore::BackendVFS>::OStoreDBWrapper(
         const std::string &context, const std::string &URL) :
-m_backend(new cta::objectstore::BackendVFS()), m_logger(new cta::log::DummyLogger("")), 
+m_logger(new cta::log::DummyLogger("")), m_backend(new cta::objectstore::BackendVFS()), 
 m_catalogue(new cta::catalogue::DummyCatalogue(*m_logger)),
 m_OStoreDB(*m_backend, *m_catalogue, *m_logger), m_agentReference("OStoreDBFactory", *m_logger) {
   // We need to populate the root entry before using.
@@ -202,7 +202,7 @@ m_OStoreDB(*m_backend, *m_catalogue, *m_logger), m_agentReference("OStoreDBFacto
 template <>
 OStoreDBWrapper<cta::objectstore::BackendRados>::OStoreDBWrapper(
         const std::string &context, const std::string &URL) :
-m_backend(cta::objectstore::BackendFactory::createBackend(URL).release()), m_logger(new cta::log::DummyLogger("")), 
+m_logger(new cta::log::DummyLogger("")), m_backend(cta::objectstore::BackendFactory::createBackend(URL, *m_logger).release()), 
 m_catalogue(new cta::catalogue::DummyCatalogue(*m_logger)),
 m_OStoreDB(*m_backend, *m_catalogue, *m_logger),  m_agentReference("OStoreDBFactory", *m_logger) {
   // We need to first clean up possible left overs in the pool
diff --git a/tapeserver/daemon/DriveHandler.cpp b/tapeserver/daemon/DriveHandler.cpp
index 3267f516bce511947e7e81913b3a5249396214c0..0ad9ea65257f1f0fc69d03734bd478cf62ab438c 100644
--- a/tapeserver/daemon/DriveHandler.cpp
+++ b/tapeserver/daemon/DriveHandler.cpp
@@ -873,7 +873,7 @@ int DriveHandler::runChild() {
   }
   // Before anything, we need to check we have access to the scheduler's central storages.
   std::unique_ptr<cta::objectstore::Backend> backend(
-    cta::objectstore::BackendFactory::createBackend(m_tapedConfig.backendPath.value()).release());
+    cta::objectstore::BackendFactory::createBackend(m_tapedConfig.backendPath.value(), lc.logger()).release());
   // If the backend is a VFS, make sure we don't delete it on exit.
   // If not, nevermind.
   try {
diff --git a/tapeserver/daemon/GarbageCollectorHandler.cpp b/tapeserver/daemon/GarbageCollectorHandler.cpp
index 024387697c9f74513c280d2aa3c62763c9959606..4859d9f2da85ee7a349bb5f6e5e2593da7e1e804 100644
--- a/tapeserver/daemon/GarbageCollectorHandler.cpp
+++ b/tapeserver/daemon/GarbageCollectorHandler.cpp
@@ -254,7 +254,7 @@ int GarbageCollectorHandler::runChild() {
   // fail likewise, so we just wait for shutdown signal (no feedback to main
   // process).
   std::unique_ptr<cta::objectstore::Backend> backend(
-    cta::objectstore::BackendFactory::createBackend(m_tapedConfig.backendPath.value()).release());
+    cta::objectstore::BackendFactory::createBackend(m_tapedConfig.backendPath.value(), m_processManager.logContext().logger()).release());
   // If the backend is a VFS, make sure we don't delete it on exit.
   // If not, nevermind.
   try {
diff --git a/xroot_plugins/XrdCtaFilesystem.cpp b/xroot_plugins/XrdCtaFilesystem.cpp
index db1f36e3354de24bd9a412561e2e5dd2388c5b3d..121f48417bc2fac6bf48fdae8331076ec2dbaf0b 100644
--- a/xroot_plugins/XrdCtaFilesystem.cpp
+++ b/xroot_plugins/XrdCtaFilesystem.cpp
@@ -278,7 +278,7 @@ XrdCtaFilesystem::XrdCtaFilesystem():
     throw cta::exception::Exception(std::string("Failed to instantiate object representing CTA logging system: ")+ex.getMessage().str());
   }
   
-  m_backend = std::move(cta::objectstore::BackendFactory::createBackend(m_ctaConf.getConfEntString("ObjectStore", "BackendPath", nullptr)));
+  m_backend = std::move(cta::objectstore::BackendFactory::createBackend(m_ctaConf.getConfEntString("ObjectStore", "BackendPath", nullptr), *m_log));
   m_backendPopulator = cta::make_unique<cta::objectstore::BackendPopulator>(*m_backend, "Frontend", cta::log::LogContext(*m_log));
   
   const rdbms::Login catalogueLogin = rdbms::Login::parseFile("/etc/cta/cta-catalogue.conf");
diff --git a/xroot_plugins/XrdSsiCtaServiceProvider.cpp b/xroot_plugins/XrdSsiCtaServiceProvider.cpp
index e1318de19707440a3e0124d9d954f4e90dd0095b..6baeb3d1d2edc47b4848d9f13bb465b35afe4352 100644
--- a/xroot_plugins/XrdSsiCtaServiceProvider.cpp
+++ b/xroot_plugins/XrdSsiCtaServiceProvider.cpp
@@ -93,7 +93,7 @@ bool XrdSsiCtaServiceProvider::Init(XrdSsiLogger *logP, XrdSsiCluster *clsP, con
 
    // Initialise the Backend
 
-   m_backend = std::move(cta::objectstore::BackendFactory::createBackend(m_ctaConf.getConfEntString("ObjectStore", "BackendPath", nullptr)));
+   m_backend = std::move(cta::objectstore::BackendFactory::createBackend(m_ctaConf.getConfEntString("ObjectStore", "BackendPath", nullptr), *m_log));
    m_backendPopulator = cta::make_unique<cta::objectstore::BackendPopulator>(*m_backend, "Frontend", cta::log::LogContext(*m_log));
    m_scheddb = cta::make_unique<cta::OStoreDBWithAgent>(*m_backend, m_backendPopulator->getAgentReference(), *m_catalogue, *m_log);