diff --git a/src/init.cpp b/src/init.cpp
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -18,7 +18,6 @@
 #include <chain.h>
 #include <chainparams.h>
 #include <checkpoints.h>
-#include <coins.h>
 #include <compat/sanity.h>
 #include <config.h>
 #include <consensus/validation.h>
@@ -143,7 +142,6 @@
 // ShutdownRequested() getting set, and then does the normal Qt shutdown thing.
 //
 
-static std::unique_ptr<CCoinsViewErrorCatcher> pcoinscatcher;
 static std::unique_ptr<ECCVerifyHandle> globalVerifyHandle;
 
 static boost::thread_group threadGroup;
@@ -244,8 +242,10 @@
 
     // FlushStateToDisk generates a ChainStateFlushed callback, which we should
     // avoid missing
-    if (pcoinsTip != nullptr) {
-        ::ChainstateActive().ForceFlushStateToDisk();
+    // g_chainstate is referenced here directly (instead of
+    // ::ChainstateActive()) because it may not have been initialized yet.
+    if (g_chainstate && g_chainstate->CanFlushToDisk()) {
+        g_chainstate->ForceFlushStateToDisk();
     }
 
     // After there are no more peers/RPC left to give us new data which may
@@ -260,12 +260,10 @@
 
     {
         LOCK(cs_main);
-        if (pcoinsTip != nullptr) {
-            ::ChainstateActive().ForceFlushStateToDisk();
+        if (g_chainstate && g_chainstate->CanFlushToDisk()) {
+            g_chainstate->ForceFlushStateToDisk();
+            g_chainstate->ResetCoinsViews();
         }
-        pcoinsTip.reset();
-        pcoinscatcher.reset();
-        pcoinsdbview.reset();
         pblocktree.reset();
     }
     for (const auto &client : node.chain_clients) {
@@ -2391,10 +2389,10 @@
             const int64_t load_block_index_start_time = GetTimeMillis();
             try {
                 LOCK(cs_main);
+                // This statement makes ::ChainstateActive() usable.
+                g_chainstate = std::make_unique<CChainState>();
                 UnloadBlockIndex();
-                pcoinsTip.reset();
-                pcoinsdbview.reset();
-                pcoinscatcher.reset();
+
                 // new CBlockTreeDB tries to delete the existing file, which
                 // fails if it's still open from the previous loop. Close it
                 // first:
@@ -2467,21 +2465,23 @@
                 // At this point we're either in reindex or we've loaded a
                 // useful block tree into BlockIndex()!
 
-                pcoinsdbview.reset(new CCoinsViewDB(
-                    nCoinDBCache, false, fReset || fReindexChainState));
-                pcoinscatcher.reset(
-                    new CCoinsViewErrorCatcher(pcoinsdbview.get()));
-                pcoinscatcher->AddReadErrCallback([]() {
-                    uiInterface.ThreadSafeMessageBox(
-                        _("Error reading from database, shutting down.")
-                            .translated,
-                        "", CClientUIInterface::MSG_ERROR);
-                });
+                ::ChainstateActive().InitCoinsDB(
+                    /* cache_size_bytes */ nCoinDBCache,
+                    /* in_memory */ false,
+                    /* should_wipe */ fReset || fReindexChainState);
+
+                ::ChainstateActive().CoinsErrorCatcher().AddReadErrCallback(
+                    []() {
+                        uiInterface.ThreadSafeMessageBox(
+                            _("Error reading from database, shutting down.")
+                                .translated,
+                            "", CClientUIInterface::MSG_ERROR);
+                    });
 
                 // If necessary, upgrade from older database format.
                 // This is a no-op if we cleared the coinsviewdb with -reindex
                 // or -reindex-chainstate
-                if (!pcoinsdbview->Upgrade()) {
+                if (!::ChainstateActive().CoinsDB().Upgrade()) {
                     strLoadError =
                         _("Error upgrading chainstate database").translated;
                     break;
@@ -2489,7 +2489,7 @@
 
                 // ReplayBlocks is a no-op if we cleared the coinsviewdb with
                 // -reindex or -reindex-chainstate
-                if (!ReplayBlocks(params, pcoinsdbview.get())) {
+                if (!ReplayBlocks(params, &::ChainstateActive().CoinsDB())) {
                     strLoadError =
                         _("Unable to replay blocks. You will need to rebuild "
                           "the database using -reindex-chainstate.")
@@ -2498,12 +2498,14 @@
                 }
 
                 // The on-disk coinsdb is now in a good state, create the cache
-                pcoinsTip.reset(new CCoinsViewCache(pcoinscatcher.get()));
+                ::ChainstateActive().InitCoinsCache();
+                assert(::ChainstateActive().CanFlushToDisk());
 
-                bool is_coinsview_empty = fReset || fReindexChainState ||
-                                          pcoinsTip->GetBestBlock().IsNull();
+                bool is_coinsview_empty =
+                    fReset || fReindexChainState ||
+                    ::ChainstateActive().CoinsTip().GetBestBlock().IsNull();
                 if (!is_coinsview_empty) {
-                    // LoadChainTip sets ::ChainActive() based on pcoinsTip's
+                    // LoadChainTip sets ::ChainActive() based on CoinsTip()'s
                     // best block
                     if (!LoadChainTip(config)) {
                         strLoadError =
@@ -2539,7 +2541,7 @@
                     }
 
                     if (!CVerifyDB().VerifyDB(
-                            config, pcoinsdbview.get(),
+                            config, &::ChainstateActive().CoinsDB(),
                             gArgs.GetArg("-checklevel", DEFAULT_CHECKLEVEL),
                             gArgs.GetArg("-checkblocks",
                                          DEFAULT_CHECKBLOCKS))) {
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -1138,7 +1138,7 @@
 
     CCoinsStats stats;
     ::ChainstateActive().ForceFlushStateToDisk();
-    if (GetUTXOStats(pcoinsdbview.get(), stats)) {
+    if (GetUTXOStats(&::ChainstateActive().CoinsDB(), stats)) {
         ret.pushKV("height", int64_t(stats.nHeight));
         ret.pushKV("bestblock", stats.hashBlock.GetHex());
         ret.pushKV("transactions", int64_t(stats.nTransactions));
@@ -2541,7 +2541,8 @@
         {
             LOCK(cs_main);
             ::ChainstateActive().ForceFlushStateToDisk();
-            pcursor = std::unique_ptr<CCoinsViewCursor>(pcoinsdbview->Cursor());
+            pcursor = std::unique_ptr<CCoinsViewCursor>(
+                ::ChainstateActive().CoinsDB().Cursor());
             CHECK_NONFATAL(pcursor);
             tip = ::ChainActive().Tip();
             CHECK_NONFATAL(tip);
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -112,8 +112,13 @@
     GetMainSignals().RegisterBackgroundSignalScheduler(*g_rpc_node->scheduler);
 
     pblocktree.reset(new CBlockTreeDB(1 << 20, true));
-    pcoinsdbview.reset(new CCoinsViewDB(1 << 23, true));
-    pcoinsTip.reset(new CCoinsViewCache(pcoinsdbview.get()));
+    g_chainstate = std::make_unique<CChainState>();
+    ::ChainstateActive().InitCoinsDB(
+        /* cache_size_bytes */ 1 << 23, /* in_memory */ true,
+        /* should_wipe */ false);
+    assert(!::ChainstateActive().CanFlushToDisk());
+    ::ChainstateActive().InitCoinsCache();
+    assert(::ChainstateActive().CanFlushToDisk());
     if (!LoadGenesisBlock(chainparams)) {
         throw std::runtime_error("LoadGenesisBlock failed.");
     }
@@ -152,8 +157,7 @@
     m_node.mempool = nullptr;
     m_node.scheduler.reset();
     UnloadBlockIndex();
-    pcoinsTip.reset();
-    pcoinsdbview.reset();
+    g_chainstate.reset();
     pblocktree.reset();
 }
 
diff --git a/src/txdb.h b/src/txdb.h
--- a/src/txdb.h
+++ b/src/txdb.h
@@ -53,8 +53,12 @@
     CDBWrapper db;
 
 public:
-    explicit CCoinsViewDB(size_t nCacheSize, bool fMemory = false,
-                          bool fWipe = false);
+    /**
+     * @param[in] ldb_path    Location in the filesystem where leveldb data will
+     * be stored.
+     */
+    explicit CCoinsViewDB(fs::path ldb_path, size_t nCacheSize, bool fMemory,
+                          bool fWipe);
 
     bool GetCoin(const COutPoint &outpoint, Coin &coin) const override;
     bool HaveCoin(const COutPoint &outpoint) const override;
diff --git a/src/txdb.cpp b/src/txdb.cpp
--- a/src/txdb.cpp
+++ b/src/txdb.cpp
@@ -54,8 +54,9 @@
 };
 } // namespace
 
-CCoinsViewDB::CCoinsViewDB(size_t nCacheSize, bool fMemory, bool fWipe)
-    : db(GetDataDir() / "chainstate", nCacheSize, fMemory, fWipe, true) {}
+CCoinsViewDB::CCoinsViewDB(fs::path ldb_path, size_t nCacheSize, bool fMemory,
+                           bool fWipe)
+    : db(ldb_path, nCacheSize, fMemory, fWipe, true) {}
 
 bool CCoinsViewDB::GetCoin(const COutPoint &outpoint, Coin &coin) const {
     return db.Read(CoinEntry(&outpoint), coin);
diff --git a/src/validation.h b/src/validation.h
--- a/src/validation.h
+++ b/src/validation.h
@@ -23,6 +23,7 @@
 #include <script/script_error.h>
 #include <script/script_metrics.h>
 #include <sync.h>
+#include <txdb.h>
 #include <txmempool.h> // For CTxMemPool::cs
 #include <versionbits.h>
 
@@ -41,7 +42,6 @@
 class CBlockUndo;
 class CChainParams;
 class CChain;
-class CCoinsViewDB;
 class CConnman;
 class CInv;
 class Config;
@@ -751,6 +751,44 @@
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 };
 
+/**
+ * A convenience class for constructing the CCoinsView* hierarchy used
+ * to facilitate access to the UTXO set.
+ *
+ * This class consists of an arrangement of layered CCoinsView objects,
+ * preferring to store and retrieve coins in memory via `m_cacheview` but
+ * ultimately falling back on cache misses to the canonical store of UTXOs on
+ * disk, `m_dbview`.
+ */
+class CoinsViews {
+public:
+    //! The lowest level of the CoinsViews cache hierarchy sits in a leveldb
+    //! database on disk. All unspent coins reside in this store.
+    CCoinsViewDB m_dbview;
+
+    //! This view wraps access to the leveldb instance and handles read errors
+    //! gracefully.
+    CCoinsViewErrorCatcher m_catcherview;
+
+    //! This is the top layer of the cache hierarchy - it keeps as many coins in
+    //! memory as can fit per the dbcache setting.
+    std::unique_ptr<CCoinsViewCache> m_cacheview;
+
+    //! This constructor initializes CCoinsViewDB and CCoinsViewErrorCatcher
+    //! instances, but it *does not* create a CCoinsViewCache instance by
+    //! default. This is done separately because the presence of the cache has
+    //! implications on whether or not we're allowed to flush the cache's state
+    //! to disk, which should not be done until the health of the database is
+    //! verified.
+    //!
+    //! All arguments forwarded onto CCoinsViewDB.
+    CoinsViews(std::string ldb_name, size_t cache_size_bytes, bool in_memory,
+               bool should_wipe);
+
+    //! Initialize the CCoinsViewCache member.
+    void InitCache();
+};
+
 /**
  * CChainState stores and provides an API to update our local knowledge of the
  * current best chain.
@@ -798,6 +836,10 @@
     //! easily as opposed to referencing a global.
     BlockManager &m_blockman;
 
+    //! Manages the UTXO set, which is a reflection of the contents of
+    //! `m_chain`.
+    std::unique_ptr<CoinsViews> m_coins_views;
+
     /**
      * The best finalized block.
      * This block cannot be reorged in any way except by explicit user action.
@@ -805,7 +847,28 @@
     const CBlockIndex *m_finalizedBlockIndex GUARDED_BY(cs_main) = nullptr;
 
 public:
-    explicit CChainState(BlockManager &blockman) : m_blockman(blockman) {}
+    CChainState(BlockManager &blockman) : m_blockman(blockman) {}
+    CChainState();
+
+    /**
+     * Initialize the CoinsViews UTXO set database management data structures.
+     * The in-memory cache is initialized separately.
+     *
+     * All parameters forwarded to CoinsViews.
+     */
+    void InitCoinsDB(size_t cache_size_bytes, bool in_memory, bool should_wipe,
+                     std::string leveldb_name = "chainstate");
+
+    //! Initialize the in-memory coins cache (to be done after the health of the
+    //! on-disk database is verified).
+    void InitCoinsCache();
+
+    //! @returns whether or not the CoinsViews object has been fully initialized
+    //! and we can
+    //!          safely flush this object to disk.
+    bool CanFlushToDisk() {
+        return m_coins_views && m_coins_views->m_cacheview;
+    }
 
     //! The current chain of blockheaders we consult and build on.
     //! @see CChain, CBlockIndex.
@@ -819,7 +882,22 @@
     std::set<CBlockIndex *, CBlockIndexWorkComparator> setBlockIndexCandidates;
 
     //! @returns A reference to the in-memory cache of the UTXO set.
-    CCoinsViewCache &CoinsTip() { return *::pcoinsTip; }
+    CCoinsViewCache &CoinsTip() {
+        assert(m_coins_views->m_cacheview);
+        return *m_coins_views->m_cacheview.get();
+    }
+
+    //! @returns A reference to the on-disk UTXO set database.
+    CCoinsViewDB &CoinsDB() { return m_coins_views->m_dbview; }
+
+    //! @returns A reference to a wrapped view of the in-memory UTXO set that
+    //!     handles disk read errors gracefully.
+    CCoinsViewErrorCatcher &CoinsErrorCatcher() {
+        return m_coins_views->m_catcherview;
+    }
+
+    //! Destructs all objects related to accessing the UTXO set.
+    void ResetCoinsViews() { m_coins_views.reset(); }
 
     /**
      * Update the on-disk chain state.
@@ -991,10 +1069,10 @@
 /** @returns the global block index map. */
 BlockMap &BlockIndex();
 
-/**
- * Global variable that points to the coins database (protected by cs_main)
- */
-extern std::unique_ptr<CCoinsViewDB> pcoinsdbview;
+// Most often ::ChainstateActive() should be used instead of this, but some code
+// may not be able to assume that this has been initialized yet and so must use
+// it directly, e.g. init.cpp.
+extern std::unique_ptr<CChainState> g_chainstate;
 
 /**
  * Global variable that points to the active block tree (protected by cs_main)
diff --git a/src/validation.cpp b/src/validation.cpp
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -63,14 +63,16 @@
 BlockManager g_blockman;
 } // namespace
 
-static CChainState g_chainstate(g_blockman);
+std::unique_ptr<CChainState> g_chainstate;
 
 CChainState &ChainstateActive() {
-    return g_chainstate;
+    assert(g_chainstate);
+    return *g_chainstate;
 }
 
 CChain &ChainActive() {
-    return g_chainstate.m_chain;
+    assert(g_chainstate);
+    return g_chainstate->m_chain;
 }
 
 /**
@@ -164,8 +166,6 @@
     return chain.Genesis();
 }
 
-std::unique_ptr<CCoinsViewDB> pcoinsdbview;
-std::unique_ptr<CCoinsViewCache> pcoinsTip;
 std::unique_ptr<CBlockTreeDB> pblocktree;
 
 // See definition for documentation
@@ -410,7 +410,7 @@
             }
 
             // Note: this call may add txin.prevout to the coins cache
-            // (pcoinsTip.cacheCoins) by way of FetchCoin(). It should be
+            // (CoinsTip().cacheCoins) by way of FetchCoin(). It should be
             // removed later (via coins_to_uncache) if this tx turns out to be
             // invalid.
             if (!view.HaveCoin(txin.prevout)) {
@@ -737,6 +737,31 @@
     return ((nSubsidy / SATOSHI) >> halvings) * SATOSHI;
 }
 
+CoinsViews::CoinsViews(std::string ldb_name, size_t cache_size_bytes,
+                       bool in_memory, bool should_wipe)
+    : m_dbview(GetDataDir() / ldb_name, cache_size_bytes, in_memory,
+               should_wipe),
+      m_catcherview(&m_dbview) {}
+
+void CoinsViews::InitCache() {
+    m_cacheview = std::make_unique<CCoinsViewCache>(&m_catcherview);
+}
+
+// NOTE: for now m_blockman is set to a global, but this will be changed
+// in a future commit.
+CChainState::CChainState() : m_blockman(g_blockman) {}
+
+void CChainState::InitCoinsDB(size_t cache_size_bytes, bool in_memory,
+                              bool should_wipe, std::string leveldb_name) {
+    m_coins_views = std::make_unique<CoinsViews>(leveldb_name, cache_size_bytes,
+                                                 in_memory, should_wipe);
+}
+
+void CChainState::InitCoinsCache() {
+    assert(m_coins_views != nullptr);
+    m_coins_views->InitCache();
+}
+
 // Note that though this is marked const, we may end up modifying
 // `m_cached_finished_ibd`, which is a performance-related implementation
 // detail. This function must be marked `const` so that `CValidationInterface`
@@ -1847,6 +1872,7 @@
                                    int nManualPruneHeight) {
     int64_t nMempoolUsage = g_mempool.DynamicMemoryUsage();
     LOCK(cs_main);
+    assert(this->CanFlushToDisk());
     static int64_t nLastWrite = 0;
     static int64_t nLastFlush = 0;
     std::set<int> setFilesToPrune;