diff --git a/src/interfaces/chain.cpp b/src/interfaces/chain.cpp
--- a/src/interfaces/chain.cpp
+++ b/src/interfaces/chain.cpp
@@ -38,7 +38,7 @@
 
     class LockImpl : public Chain::Lock, public UniqueLock<RecursiveMutex> {
         Optional<int> getHeight() override {
-            LockAnnotation lock(::cs_main);
+            LockAssertion lock(::cs_main);
             int height = ::ChainActive().Height();
             if (height >= 0) {
                 return height;
@@ -46,7 +46,7 @@
             return nullopt;
         }
         Optional<int> getBlockHeight(const BlockHash &hash) override {
-            LockAnnotation lock(::cs_main);
+            LockAssertion lock(::cs_main);
             CBlockIndex *block = LookupBlockIndex(hash);
             if (block && ::ChainActive().Contains(block)) {
                 return block->nHeight;
@@ -59,32 +59,32 @@
             return tip_height && height ? *tip_height - *height + 1 : 0;
         }
         BlockHash getBlockHash(int height) override {
-            LockAnnotation lock(::cs_main);
+            LockAssertion lock(::cs_main);
             CBlockIndex *block = ::ChainActive()[height];
             assert(block != nullptr);
             return block->GetBlockHash();
         }
         int64_t getBlockTime(int height) override {
-            LockAnnotation lock(::cs_main);
+            LockAssertion lock(::cs_main);
             CBlockIndex *block = ::ChainActive()[height];
             assert(block != nullptr);
             return block->GetBlockTime();
         }
         int64_t getBlockMedianTimePast(int height) override {
-            LockAnnotation lock(::cs_main);
+            LockAssertion lock(::cs_main);
             CBlockIndex *block = ::ChainActive()[height];
             assert(block != nullptr);
             return block->GetMedianTimePast();
         }
         bool haveBlockOnDisk(int height) override {
-            LockAnnotation lock(::cs_main);
+            LockAssertion lock(::cs_main);
             CBlockIndex *block = ::ChainActive()[height];
             return block && (block->nStatus.hasData() != 0) && block->nTx > 0;
         }
         Optional<int>
         findFirstBlockWithTimeAndHeight(int64_t time, int height,
                                         BlockHash *hash) override {
-            LockAnnotation lock(::cs_main);
+            LockAssertion lock(::cs_main);
             CBlockIndex *block =
                 ::ChainActive().FindEarliestAtLeast(time, height);
             if (block) {
@@ -97,7 +97,7 @@
         }
         Optional<int> findPruned(int start_height,
                                  Optional<int> stop_height) override {
-            LockAnnotation lock(::cs_main);
+            LockAssertion lock(::cs_main);
             if (::fPruneMode) {
                 CBlockIndex *block = stop_height ? ::ChainActive()[*stop_height]
                                                  : ::ChainActive().Tip();
@@ -112,7 +112,7 @@
         }
         Optional<int> findFork(const BlockHash &hash,
                                Optional<int> *height) override {
-            LockAnnotation lock(::cs_main);
+            LockAssertion lock(::cs_main);
             const CBlockIndex *block = LookupBlockIndex(hash);
             const CBlockIndex *fork =
                 block ? ::ChainActive().FindFork(block) : nullptr;
@@ -129,11 +129,11 @@
             return nullopt;
         }
         CBlockLocator getTipLocator() override {
-            LockAnnotation lock(::cs_main);
+            LockAssertion lock(::cs_main);
             return ::ChainActive().GetLocator();
         }
         Optional<int> findLocatorFork(const CBlockLocator &locator) override {
-            LockAnnotation lock(::cs_main);
+            LockAssertion lock(::cs_main);
             if (CBlockIndex *fork =
                     FindForkInGlobalIndex(::ChainActive(), locator)) {
                 return fork->nHeight;
@@ -143,13 +143,13 @@
         bool contextualCheckTransactionForCurrentBlock(
             const Consensus::Params &params, const CTransaction &tx,
             CValidationState &state) override {
-            LockAnnotation lock(::cs_main);
+            LockAssertion lock(::cs_main);
             return ContextualCheckTransactionForCurrentBlock(params, tx, state);
         }
         bool submitToMemoryPool(const Config &config, CTransactionRef tx,
                                 Amount absurd_fee,
                                 CValidationState &state) override {
-            LockAnnotation lock(::cs_main);
+            LockAssertion lock(::cs_main);
             return AcceptToMemoryPool(config, ::g_mempool, state, tx,
                                       nullptr /* missing inputs */,
                                       false /* bypass limits */, absurd_fee);
diff --git a/src/qt/test/wallettests.cpp b/src/qt/test/wallettests.cpp
--- a/src/qt/test/wallettests.cpp
+++ b/src/qt/test/wallettests.cpp
@@ -130,7 +130,7 @@
     }
     {
         auto locked_chain = wallet->chain().lock();
-        LockAnnotation lock(::cs_main);
+        LockAssertion lock(::cs_main);
 
         WalletRescanReserver reserver(wallet.get());
         reserver.reserve();
diff --git a/src/sync.h b/src/sync.h
--- a/src/sync.h
+++ b/src/sync.h
@@ -299,14 +299,14 @@
 
 // Utility class for indicating to compiler thread analysis that a mutex is
 // locked (when it couldn't be determined otherwise).
-struct SCOPED_LOCKABLE LockAnnotation {
+struct SCOPED_LOCKABLE LockAssertion {
     template <typename Mutex>
-    explicit LockAnnotation(Mutex &mutex) EXCLUSIVE_LOCK_FUNCTION(mutex) {
+    explicit LockAssertion(Mutex &mutex) EXCLUSIVE_LOCK_FUNCTION(mutex) {
 #ifdef DEBUG_LOCKORDER
         AssertLockHeld(mutex);
 #endif
     }
-    ~LockAnnotation() UNLOCK_FUNCTION() {}
+    ~LockAssertion() UNLOCK_FUNCTION() {}
 };
 
 #endif // BITCOIN_SYNC_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
@@ -41,7 +41,7 @@
 
     auto chain = interfaces::MakeChain();
     auto locked_chain = chain->lock();
-    LockAnnotation lock(::cs_main);
+    LockAssertion lock(::cs_main);
 
     // Verify ScanForWalletTransactions accommodates a null start block.
     {
@@ -127,7 +127,7 @@
 
     auto chain = interfaces::MakeChain();
     auto locked_chain = chain->lock();
-    LockAnnotation lock(::cs_main);
+    LockAssertion lock(::cs_main);
 
     // Prune the older block file.
     PruneOneBlockFile(oldTip->GetBlockPos().nFile);
@@ -212,7 +212,7 @@
 
     auto chain = interfaces::MakeChain();
     auto locked_chain = chain->lock();
-    LockAnnotation lock(::cs_main);
+    LockAssertion lock(::cs_main);
 
     std::string backup_file = (GetDataDir() / "wallet.backup").string();
 
@@ -272,7 +272,7 @@
     CWalletTx wtx(&wallet, m_coinbase_txns.back());
 
     auto locked_chain = chain->lock();
-    LockAnnotation lock(::cs_main);
+    LockAssertion lock(::cs_main);
     LOCK(wallet.cs_wallet);
 
     wtx.hashBlock = ::ChainActive().Tip()->GetBlockHash();
@@ -297,7 +297,7 @@
     CBlockIndex *block = nullptr;
     if (blockTime > 0) {
         auto locked_chain = wallet.chain().lock();
-        LockAnnotation lock(::cs_main);
+        LockAssertion lock(::cs_main);
         auto inserted =
             mapBlockIndex.emplace(BlockHash(GetRandHash()), new CBlockIndex);
         assert(inserted.second);