diff --git a/arcanist/linter/CheckNonFatalOverAssertInRpc.php b/arcanist/linter/CheckNonFatalOverAssertInRpc.php
--- a/arcanist/linter/CheckNonFatalOverAssertInRpc.php
+++ b/arcanist/linter/CheckNonFatalOverAssertInRpc.php
@@ -45,7 +45,7 @@
     $absPath = Filesystem::resolvePath($path, $this->getProjectRoot());
     $fileContent = Filesystem::readFile($absPath);
 
-    if (!preg_match_all("/(assert\((.*)\);)/", $fileContent,
+    if (!preg_match_all("/((A|a)ssert\((.*)\);)/", $fileContent,
       $matches, PREG_OFFSET_CAPTURE)) {
       return;
     }
diff --git a/src/init.cpp b/src/init.cpp
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -55,6 +55,7 @@
 #include <txmempool.h>
 #include <ui_interface.h>
 #include <util/asmap.h>
+#include <util/check.h>
 #include <util/moneystr.h>
 #include <util/threadnames.h>
 #include <util/translation.h>
@@ -2213,11 +2214,10 @@
         GetRand(std::numeric_limits<uint64_t>::max()));
     assert(!node.chainman);
     node.chainman = &g_chainman;
-    ChainstateManager &chainman = EnsureChainman(node);
+    ChainstateManager &chainman = *Assert(node.chainman);
 
-    node.peer_logic.reset(
-        new PeerLogicValidation(node.connman.get(), node.banman.get(),
-                                *node.scheduler, *node.chainman));
+    node.peer_logic.reset(new PeerLogicValidation(
+        node.connman.get(), node.banman.get(), *node.scheduler, chainman));
     RegisterValidationInterface(node.peer_logic.get());
 
     // sanitize comments per BIP-0014, format user agent and check total size
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -30,6 +30,7 @@
 #include <scheduler.h>
 #include <tinyformat.h>
 #include <txmempool.h>
+#include <util/check.h> // For NDEBUG compile time check
 #include <util/strencodings.h>
 #include <util/system.h>
 #include <validation.h>
@@ -37,10 +38,6 @@
 #include <memory>
 #include <typeinfo>
 
-#if defined(NDEBUG)
-#error "Bitcoin cannot be compiled without assertions."
-#endif
-
 /** Expiration time for orphan transactions in seconds */
 static constexpr int64_t ORPHAN_TX_EXPIRE_TIME = 20 * 60;
 /** Minimum time between orphan transactions expire time checks in seconds */
diff --git a/src/node/context.h b/src/node/context.h
--- a/src/node/context.h
+++ b/src/node/context.h
@@ -49,9 +49,4 @@
     ~NodeContext();
 };
 
-inline ChainstateManager &EnsureChainman(const NodeContext &node) {
-    assert(node.chainman);
-    return *node.chainman;
-}
-
 #endif // BITCOIN_NODE_CONTEXT_H
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -70,7 +70,10 @@
 
 ChainstateManager &EnsureChainman(const util::Ref &context) {
     NodeContext &node = EnsureNodeContext(context);
-    return EnsureChainman(node);
+    if (!node.chainman) {
+        throw JSONRPCError(RPC_INTERNAL_ERROR, "Node chainman not found");
+    }
+    return *node.chainman;
 }
 
 /**
diff --git a/src/test/blockfilter_index_tests.cpp b/src/test/blockfilter_index_tests.cpp
--- a/src/test/blockfilter_index_tests.cpp
+++ b/src/test/blockfilter_index_tests.cpp
@@ -103,8 +103,9 @@
         CBlockHeader header = block->GetBlockHeader();
 
         BlockValidationState state;
-        if (!EnsureChainman(m_node).ProcessNewBlockHeaders(
-                GetConfig(), {header}, state, &pindex)) {
+        if (!Assert(m_node.chainman)
+                 ->ProcessNewBlockHeaders(GetConfig(), {header}, state,
+                                          &pindex)) {
             return false;
         }
     }
@@ -190,8 +191,8 @@
     uint256 chainA_last_header = last_header;
     for (size_t i = 0; i < 2; i++) {
         const auto &block = chainA[i];
-        BOOST_REQUIRE(EnsureChainman(m_node).ProcessNewBlock(GetConfig(), block,
-                                                             true, nullptr));
+        BOOST_REQUIRE(Assert(m_node.chainman)
+                          ->ProcessNewBlock(GetConfig(), block, true, nullptr));
     }
     for (size_t i = 0; i < 2; i++) {
         const auto &block = chainA[i];
@@ -209,8 +210,8 @@
     uint256 chainB_last_header = last_header;
     for (size_t i = 0; i < 3; i++) {
         const auto &block = chainB[i];
-        BOOST_REQUIRE(EnsureChainman(m_node).ProcessNewBlock(GetConfig(), block,
-                                                             true, nullptr));
+        BOOST_REQUIRE(Assert(m_node.chainman)
+                          ->ProcessNewBlock(GetConfig(), block, true, nullptr));
     }
     for (size_t i = 0; i < 3; i++) {
         const auto &block = chainB[i];
@@ -241,8 +242,8 @@
     // Reorg back to chain A.
     for (size_t i = 2; i < 4; i++) {
         const auto &block = chainA[i];
-        BOOST_REQUIRE(EnsureChainman(m_node).ProcessNewBlock(GetConfig(), block,
-                                                             true, nullptr));
+        BOOST_REQUIRE(Assert(m_node.chainman)
+                          ->ProcessNewBlock(GetConfig(), block, true, nullptr));
     }
 
     // Check that chain A and B blocks can be retrieved.
diff --git a/src/test/checkpoints_tests.cpp b/src/test/checkpoints_tests.cpp
--- a/src/test/checkpoints_tests.cpp
+++ b/src/test/checkpoints_tests.cpp
@@ -91,8 +91,9 @@
 
     {
         BlockValidationState state;
-        BOOST_CHECK(EnsureChainman(m_node).ProcessNewBlockHeaders(
-            config, {headerG}, state, &pindex));
+        BOOST_CHECK(
+            Assert(m_node.chainman)
+                ->ProcessNewBlockHeaders(config, {headerG}, state, &pindex));
         pindex = nullptr;
     }
 
@@ -156,8 +157,9 @@
     // Headers A and AA should be accepted
     {
         BlockValidationState state;
-        BOOST_CHECK(EnsureChainman(m_node).ProcessNewBlockHeaders(
-            config, {headerA}, state, &pindex));
+        BOOST_CHECK(
+            Assert(m_node.chainman)
+                ->ProcessNewBlockHeaders(config, {headerA}, state, &pindex));
         BOOST_CHECK(state.IsValid());
         BOOST_CHECK(pindex != nullptr);
         pindex = nullptr;
@@ -165,8 +167,9 @@
 
     {
         BlockValidationState state;
-        BOOST_CHECK(EnsureChainman(m_node).ProcessNewBlockHeaders(
-            config, {headerAA}, state, &pindex));
+        BOOST_CHECK(
+            Assert(m_node.chainman)
+                ->ProcessNewBlockHeaders(config, {headerAA}, state, &pindex));
         BOOST_CHECK(state.IsValid());
         BOOST_CHECK(pindex != nullptr);
         pindex = nullptr;
@@ -175,8 +178,9 @@
     // Header B should be rejected
     {
         BlockValidationState state;
-        BOOST_CHECK(!EnsureChainman(m_node).ProcessNewBlockHeaders(
-            config, {headerB}, state, &pindex));
+        BOOST_CHECK(
+            !Assert(m_node.chainman)
+                 ->ProcessNewBlockHeaders(config, {headerB}, state, &pindex));
         BOOST_CHECK(state.IsInvalid());
         BOOST_CHECK(state.GetRejectReason() == "bad-fork-prior-to-checkpoint");
         BOOST_CHECK(pindex == nullptr);
@@ -191,8 +195,9 @@
     // Header AB should be rejected
     {
         BlockValidationState state;
-        BOOST_CHECK(!EnsureChainman(m_node).ProcessNewBlockHeaders(
-            config, {headerAB}, state, &pindex));
+        BOOST_CHECK(
+            !Assert(m_node.chainman)
+                 ->ProcessNewBlockHeaders(config, {headerAB}, state, &pindex));
         BOOST_CHECK(state.IsInvalid());
         BOOST_CHECK(state.GetRejectReason() == "checkpoint mismatch");
         BOOST_CHECK(pindex == nullptr);
diff --git a/src/test/miner_tests.cpp b/src/test/miner_tests.cpp
--- a/src/test/miner_tests.cpp
+++ b/src/test/miner_tests.cpp
@@ -321,8 +321,9 @@
         }
         std::shared_ptr<const CBlock> shared_pblock =
             std::make_shared<const CBlock>(*pblock);
-        BOOST_CHECK(EnsureChainman(m_node).ProcessNewBlock(
-            config, shared_pblock, true, nullptr));
+        BOOST_CHECK(
+            Assert(m_node.chainman)
+                ->ProcessNewBlock(config, shared_pblock, true, nullptr));
         pblock->hashPrevBlock = pblock->GetHash();
     }
 
diff --git a/src/test/util/mining.cpp b/src/test/util/mining.cpp
--- a/src/test/util/mining.cpp
+++ b/src/test/util/mining.cpp
@@ -12,6 +12,7 @@
 #include <node/context.h>
 #include <pow/pow.h>
 #include <script/standard.h>
+#include <util/check.h>
 #include <validation.h>
 
 const std::string ADDRESS_BCHREG_UNSPENDABLE =
@@ -37,7 +38,7 @@
     }
 
     bool processed{
-        EnsureChainman(node).ProcessNewBlock(config, block, true, nullptr)};
+        Assert(node.chainman)->ProcessNewBlock(config, block, true, nullptr)};
     assert(processed);
 
     return CTxIn{block->vtx[0]->GetId(), 0};
@@ -46,9 +47,8 @@
 std::shared_ptr<CBlock> PrepareBlock(const Config &config,
                                      const NodeContext &node,
                                      const CScript &coinbase_scriptPubKey) {
-    assert(node.mempool);
     auto block =
-        std::make_shared<CBlock>(BlockAssembler{config, *node.mempool}
+        std::make_shared<CBlock>(BlockAssembler{config, *Assert(node.mempool)}
                                      .CreateNewBlock(coinbase_scriptPubKey)
                                      ->block);
 
diff --git a/src/test/util/setup_common.h b/src/test/util/setup_common.h
--- a/src/test/util/setup_common.h
+++ b/src/test/util/setup_common.h
@@ -14,6 +14,7 @@
 #include <pubkey.h>
 #include <random.h>
 #include <scheduler.h>
+#include <util/check.h>
 #include <util/system.h>
 
 #include <boost/thread.hpp> // For boost::thread_group
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
@@ -252,8 +252,8 @@
 
     std::shared_ptr<const CBlock> shared_pblock =
         std::make_shared<const CBlock>(block);
-    EnsureChainman(m_node).ProcessNewBlock(config, shared_pblock, true,
-                                           nullptr);
+    Assert(m_node.chainman)
+        ->ProcessNewBlock(config, shared_pblock, true, nullptr);
 
     CBlock result = block;
     return result;
diff --git a/src/test/validation_block_tests.cpp b/src/test/validation_block_tests.cpp
--- a/src/test/validation_block_tests.cpp
+++ b/src/test/validation_block_tests.cpp
@@ -186,13 +186,15 @@
         [](std::shared_ptr<const CBlock> b) { return b->GetBlockHeader(); });
 
     // Process all the headers so we understand the toplogy of the chain
-    BOOST_CHECK(
-        EnsureChainman(m_node).ProcessNewBlockHeaders(config, headers, state));
+    BOOST_CHECK(Assert(m_node.chainman)
+                    ->ProcessNewBlockHeaders(config, headers, state));
 
     // Connect the genesis block and drain any outstanding events
-    BOOST_CHECK(EnsureChainman(m_node).ProcessNewBlock(
-        config, std::make_shared<CBlock>(chainParams.GenesisBlock()), true,
-        &ignored));
+    BOOST_CHECK(Assert(m_node.chainman)
+                    ->ProcessNewBlock(
+                        config,
+                        std::make_shared<CBlock>(chainParams.GenesisBlock()),
+                        true, &ignored));
     SyncWithValidationInterfaceQueue();
 
     // subscribe to events (this subscriber will validate event ordering)
@@ -215,16 +217,17 @@
             FastRandomContext insecure;
             for (int j = 0; j < 1000; j++) {
                 auto block = blocks[insecure.randrange(blocks.size() - 1)];
-                EnsureChainman(m_node).ProcessNewBlock(config, block, true,
-                                                       &tlignored);
+                Assert(m_node.chainman)
+                    ->ProcessNewBlock(config, block, true, &tlignored);
             }
 
             // to make sure that eventually we process the full chain - do it
             // here
             for (auto block : blocks) {
                 if (block->vtx.size() == 1) {
-                    bool processed = EnsureChainman(m_node).ProcessNewBlock(
-                        config, block, true, &tlignored);
+                    bool processed =
+                        Assert(m_node.chainman)
+                            ->ProcessNewBlock(config, block, true, &tlignored);
                     assert(processed);
                 }
             }
@@ -269,9 +272,9 @@
 
     bool ignored;
     auto ProcessBlock = [&](std::shared_ptr<const CBlock> block) -> bool {
-        return EnsureChainman(m_node).ProcessNewBlock(
-            config, block, /* fForceProcessing */ true,
-            /* fNewBlock */ &ignored);
+        return Assert(m_node.chainman)
+            ->ProcessNewBlock(config, block, /* fForceProcessing */ true,
+                              /* fNewBlock */ &ignored);
     };
 
     // Process all mined blocks
diff --git a/src/util/check.h b/src/util/check.h
--- a/src/util/check.h
+++ b/src/util/check.h
@@ -26,7 +26,7 @@
  * - where a failure to fulfill the condition is recoverable and does not abort
  * the program
  *
- * For example in RPC code, where it is undersirable to crash the whole program,
+ * For example in RPC code, where it is undesirable to crash the whole program,
  * this can be generally used to replace asserts or recoverable logic errors. A
  * NonFatalCheckError in RPC code is caught and passed as a string to the RPC
  * caller, which can then report the issue to the developers.
@@ -43,4 +43,22 @@
         }                                                                      \
     } while (false)
 
+#if defined(NDEBUG)
+#error "Cannot compile without assertions!"
+#endif
+
+/** Helper for Assert(). TODO remove in C++14 and replace
+ * `decltype(get_pure_r_value(val))` with `T` (templated lambda) */
+template <typename T> T get_pure_r_value(T &&val) {
+    return std::forward<T>(val);
+}
+
+/** Identity function. Abort if the value compares equal to zero */
+#define Assert(val)                                                            \
+    [&]() -> decltype(get_pure_r_value(val)) & {                               \
+        auto &check = (val);                                                   \
+        assert(#val &&check);                                                  \
+        return check;                                                          \
+    }()
+
 #endif // BITCOIN_UTIL_CHECK_H
diff --git a/src/validation.cpp b/src/validation.cpp
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -42,6 +42,7 @@
 #include <txmempool.h>
 #include <ui_interface.h>
 #include <undo.h>
+#include <util/check.h> // For NDEBUG compile time check
 #include <util/moneystr.h>
 #include <util/strencodings.h>
 #include <util/system.h>
diff --git a/src/wallet/test/wallet_tests.cpp b/src/wallet/test/wallet_tests.cpp
--- a/src/wallet/test/wallet_tests.cpp
+++ b/src/wallet/test/wallet_tests.cpp
@@ -93,7 +93,7 @@
     // Prune the older block file.
     {
         LOCK(cs_main);
-        EnsureChainman(m_node).PruneOneBlockFile(oldTip->GetBlockPos().nFile);
+        Assert(m_node.chainman)->PruneOneBlockFile(oldTip->GetBlockPos().nFile);
     }
     UnlinkPrunedFiles({oldTip->GetBlockPos().nFile});
 
@@ -123,7 +123,7 @@
     // Prune the remaining block file.
     {
         LOCK(cs_main);
-        EnsureChainman(m_node).PruneOneBlockFile(newTip->GetBlockPos().nFile);
+        Assert(m_node.chainman)->PruneOneBlockFile(newTip->GetBlockPos().nFile);
     }
     UnlinkPrunedFiles({newTip->GetBlockPos().nFile});
 
@@ -163,7 +163,7 @@
     // Prune the older block file.
     {
         LOCK(cs_main);
-        EnsureChainman(m_node).PruneOneBlockFile(oldTip->GetBlockPos().nFile);
+        Assert(m_node.chainman)->PruneOneBlockFile(oldTip->GetBlockPos().nFile);
     }
     UnlinkPrunedFiles({oldTip->GetBlockPos().nFile});