diff --git a/src/interfaces/node.h b/src/interfaces/node.h
--- a/src/interfaces/node.h
+++ b/src/interfaces/node.h
@@ -119,6 +119,9 @@
     //! Get num blocks.
     virtual int getNumBlocks() = 0;
 
+    //! Get best block hash.
+    virtual BlockHash getBestBlockHash() = 0;
+
     //! Get last block time.
     virtual int64_t getLastBlockTime() = 0;
 
@@ -236,16 +239,16 @@
     handleBannedListChanged(BannedListChangedFn fn) = 0;
 
     //! Register handler for block tip messages.
-    using NotifyBlockTipFn =
-        std::function<void(SynchronizationState, int height, int64_t block_time,
-                           double verification_progress)>;
+    using NotifyBlockTipFn = std::function<void(
+        SynchronizationState, const BlockHash &block_hash, int height,
+        int64_t block_time, double verification_progress)>;
     virtual std::unique_ptr<Handler>
     handleNotifyBlockTip(NotifyBlockTipFn fn) = 0;
 
     //! Register handler for header tip messages.
-    using NotifyHeaderTipFn =
-        std::function<void(SynchronizationState, int height, int64_t block_time,
-                           double verification_progress)>;
+    using NotifyHeaderTipFn = std::function<void(
+        SynchronizationState, const BlockHash &block_hash, int height,
+        int64_t block_time, double verification_progress)>;
     virtual std::unique_ptr<Handler>
     handleNotifyHeaderTip(NotifyHeaderTipFn fn) = 0;
 
diff --git a/src/interfaces/node.cpp b/src/interfaces/node.cpp
--- a/src/interfaces/node.cpp
+++ b/src/interfaces/node.cpp
@@ -193,6 +193,12 @@
             LOCK(::cs_main);
             return ::ChainActive().Height();
         }
+        BlockHash getBestBlockHash() override {
+            const CBlockIndex *tip =
+                WITH_LOCK(::cs_main, return ::ChainActive().Tip());
+            return tip ? tip->GetBlockHash()
+                       : Params().GenesisBlock().GetHash();
+        }
         int64_t getLastBlockTime() override {
             LOCK(::cs_main);
             if (::ChainActive().Tip()) {
@@ -323,7 +329,8 @@
             return MakeHandler(::uiInterface.NotifyBlockTip_connect(
                 [fn](SynchronizationState sync_state,
                      const CBlockIndex *block) {
-                    fn(sync_state, block->nHeight, block->GetBlockTime(),
+                    fn(sync_state, block->GetBlockHash(), block->nHeight,
+                       block->GetBlockTime(),
                        GuessVerificationProgress(Params().TxData(), block));
                 }));
         }
@@ -333,7 +340,8 @@
             return MakeHandler(::uiInterface.NotifyHeaderTip_connect(
                 [fn](SynchronizationState sync_state,
                      const CBlockIndex *block) {
-                    fn(sync_state, block->nHeight, block->GetBlockTime(), 0);
+                    fn(sync_state, block->GetBlockHash(), block->nHeight,
+                       block->GetBlockTime(), 0);
                 }));
         }
         NodeContext *context() override { return m_context; }
diff --git a/src/interfaces/wallet.h b/src/interfaces/wallet.h
--- a/src/interfaces/wallet.h
+++ b/src/interfaces/wallet.h
@@ -5,7 +5,8 @@
 #ifndef BITCOIN_INTERFACES_WALLET_H
 #define BITCOIN_INTERFACES_WALLET_H
 
-#include <amount.h>                 // For Amount
+#include <amount.h> // For Amount
+#include <primitives/blockhash.h>
 #include <primitives/transaction.h> // For CTxOut
 #include <pubkey.h> // For CKeyID and CScriptID (definitions needed in CTxDestination instantiation)
 #include <script/sighashtype.h>
@@ -199,7 +200,8 @@
     virtual WalletBalances getBalances() = 0;
 
     //! Get balances if possible without blocking.
-    virtual bool tryGetBalances(WalletBalances &balances, int &num_blocks) = 0;
+    virtual bool tryGetBalances(WalletBalances &balances,
+                                BlockHash &block_hash) = 0;
 
     //! Get balance.
     virtual Amount getBalance() = 0;
diff --git a/src/interfaces/wallet.cpp b/src/interfaces/wallet.cpp
--- a/src/interfaces/wallet.cpp
+++ b/src/interfaces/wallet.cpp
@@ -332,12 +332,12 @@
             return result;
         }
         bool tryGetBalances(WalletBalances &balances,
-                            int &num_blocks) override {
+                            BlockHash &block_hash) override {
             TRY_LOCK(m_wallet->cs_wallet, locked_wallet);
             if (!locked_wallet) {
                 return false;
             }
-            num_blocks = m_wallet->GetLastBlockHeight();
+            block_hash = m_wallet->GetLastBlockHash();
             balances = getBalances();
             return true;
         }
diff --git a/src/qt/clientmodel.h b/src/qt/clientmodel.h
--- a/src/qt/clientmodel.h
+++ b/src/qt/clientmodel.h
@@ -10,6 +10,8 @@
 
 #include <atomic>
 #include <memory>
+#include <primitives/blockhash.h>
+#include <sync.h>
 
 class BanTableModel;
 class CBlockIndex;
@@ -54,6 +56,7 @@
     //! Return number of connections, default is in- and outbound (total)
     int getNumConnections(NumConnections flags = CONNECTIONS_ALL) const;
     int getNumBlocks() const;
+    BlockHash getBestBlockHash();
     int getHeaderTipHeight() const;
     int64_t getHeaderTipTime() const;
 
@@ -76,6 +79,9 @@
     mutable std::atomic<int64_t> cachedBestHeaderTime;
     mutable std::atomic<int> m_cached_num_blocks{-1};
 
+    Mutex m_cached_tip_mutex;
+    BlockHash m_cached_tip_blocks GUARDED_BY(m_cached_tip_mutex){};
+
 private:
     interfaces::Node &m_node;
     std::unique_ptr<interfaces::Handler> m_handler_show_progress;
diff --git a/src/qt/clientmodel.cpp b/src/qt/clientmodel.cpp
--- a/src/qt/clientmodel.cpp
+++ b/src/qt/clientmodel.cpp
@@ -110,6 +110,28 @@
     return m_cached_num_blocks;
 }
 
+BlockHash ClientModel::getBestBlockHash() {
+    BlockHash tip{WITH_LOCK(m_cached_tip_mutex, return m_cached_tip_blocks)};
+
+    if (!tip.IsNull()) {
+        return tip;
+    }
+
+    // Lock order must be: first `cs_main`, then `m_cached_tip_mutex`.
+    // The following will lock `cs_main` (and release it), so we must not
+    // own `m_cached_tip_mutex` here.
+    tip = m_node.getBestBlockHash();
+
+    LOCK(m_cached_tip_mutex);
+    // We checked that `m_cached_tip_blocks` is not null above, but then we
+    // released the mutex `m_cached_tip_mutex`, so it could have changed in the
+    // meantime. Thus, check again.
+    if (m_cached_tip_blocks.IsNull()) {
+        m_cached_tip_blocks = tip;
+    }
+    return m_cached_tip_blocks;
+}
+
 void ClientModel::updateNumConnections(int numConnections) {
     Q_EMIT numConnectionsChanged(numConnections);
 }
@@ -221,7 +243,8 @@
 }
 
 static void BlockTipChanged(ClientModel *clientmodel,
-                            SynchronizationState sync_state, int height,
+                            SynchronizationState sync_state,
+                            const BlockHash block_hash, int height,
                             int64_t blockTime, double verificationProgress,
                             bool fHeader) {
     if (fHeader) {
@@ -230,6 +253,8 @@
         clientmodel->cachedBestHeaderTime = blockTime;
     } else {
         clientmodel->m_cached_num_blocks = height;
+        WITH_LOCK(clientmodel->m_cached_tip_mutex,
+                  clientmodel->m_cached_tip_blocks = block_hash;);
     }
 
     // Throttle GUI notifications about (a) blocks during initial sync, and (b)
@@ -268,12 +293,14 @@
         m_node.handleNotifyAlertChanged(std::bind(NotifyAlertChanged, this));
     m_handler_banned_list_changed =
         m_node.handleBannedListChanged(std::bind(BannedListChanged, this));
-    m_handler_notify_block_tip = m_node.handleNotifyBlockTip(std::bind(
-        BlockTipChanged, this, std::placeholders::_1, std::placeholders::_2,
-        std::placeholders::_3, std::placeholders::_4, false));
-    m_handler_notify_header_tip = m_node.handleNotifyHeaderTip(std::bind(
-        BlockTipChanged, this, std::placeholders::_1, std::placeholders::_2,
-        std::placeholders::_3, std::placeholders::_4, true));
+    m_handler_notify_block_tip = m_node.handleNotifyBlockTip(
+        std::bind(BlockTipChanged, this, std::placeholders::_1,
+                  std::placeholders::_2, std::placeholders::_3,
+                  std::placeholders::_4, std::placeholders::_5, false));
+    m_handler_notify_header_tip = m_node.handleNotifyHeaderTip(
+        std::bind(BlockTipChanged, this, std::placeholders::_1,
+                  std::placeholders::_2, std::placeholders::_3,
+                  std::placeholders::_4, std::placeholders::_5, true));
 }
 
 void ClientModel::unsubscribeFromCoreSignals() {
diff --git a/src/qt/transactionrecord.h b/src/qt/transactionrecord.h
--- a/src/qt/transactionrecord.h
+++ b/src/qt/transactionrecord.h
@@ -6,6 +6,7 @@
 #define BITCOIN_QT_TRANSACTIONRECORD_H
 
 #include <amount.h>
+#include <primitives/blockhash.h>
 #include <primitives/txid.h>
 
 #include <QList>
@@ -26,7 +27,7 @@
 public:
     TransactionStatus()
         : countsForBalance(false), sortKey(""), matures_in(0),
-          status(Unconfirmed), depth(0), open_for(0), cur_num_blocks(-1) {}
+          status(Unconfirmed), depth(0), open_for(0) {}
 
     enum Status {
         /**
@@ -77,9 +78,10 @@
 
     /**@}*/
 
-    /** Current number of blocks (to know whether cached status is still valid)
+    /**
+     * Current block hash (to know whether cached status is still valid)
      */
-    int cur_num_blocks;
+    BlockHash m_cur_block_hash{};
 };
 
 /**
@@ -148,12 +150,13 @@
 
     /** Update status from core wallet tx.
      */
-    void updateStatus(const interfaces::WalletTxStatus &wtx, int numBlocks,
+    void updateStatus(const interfaces::WalletTxStatus &wtx,
+                      const BlockHash &block_hash, int numBlocks,
                       int64_t block_time);
 
     /** Return whether a status update is needed.
      */
-    bool statusUpdateNeeded(int numBlocks) const;
+    bool statusUpdateNeeded(const BlockHash &block_hash) const;
 };
 
 #endif // BITCOIN_QT_TRANSACTIONRECORD_H
diff --git a/src/qt/transactionrecord.cpp b/src/qt/transactionrecord.cpp
--- a/src/qt/transactionrecord.cpp
+++ b/src/qt/transactionrecord.cpp
@@ -162,7 +162,8 @@
 }
 
 void TransactionRecord::updateStatus(const interfaces::WalletTxStatus &wtx,
-                                     int numBlocks, int64_t block_time) {
+                                     const BlockHash &block_hash, int numBlocks,
+                                     int64_t block_time) {
     // Determine transaction status
 
     // Sort order, unrecorded transactions sort to the top
@@ -170,7 +171,7 @@
                                wtx.is_coinbase ? 1 : 0, wtx.time_received, idx);
     status.countsForBalance = wtx.is_trusted && !(wtx.blocks_to_maturity > 0);
     status.depth = wtx.depth_in_main_chain;
-    status.cur_num_blocks = numBlocks;
+    status.m_cur_block_hash = block_hash;
 
     const bool up_to_date =
         (int64_t(QDateTime::currentMSecsSinceEpoch()) / 1000 - block_time <
@@ -212,8 +213,8 @@
     }
 }
 
-bool TransactionRecord::statusUpdateNeeded(int numBlocks) const {
-    return status.cur_num_blocks != numBlocks;
+bool TransactionRecord::statusUpdateNeeded(const BlockHash &block_hash) const {
+    return status.m_cur_block_hash != block_hash;
 }
 
 QString TransactionRecord::getTxID() const {
diff --git a/src/qt/transactiontablemodel.cpp b/src/qt/transactiontablemodel.cpp
--- a/src/qt/transactiontablemodel.cpp
+++ b/src/qt/transactiontablemodel.cpp
@@ -172,7 +172,7 @@
     int size() { return cachedWallet.size(); }
 
     TransactionRecord *index(interfaces::Wallet &wallet,
-                             const int cur_num_blocks, const int idx) {
+                             const BlockHash &cur_block_hash, const int idx) {
         if (idx >= 0 && idx < cachedWallet.size()) {
             TransactionRecord *rec = &cachedWallet[idx];
 
@@ -186,9 +186,9 @@
             interfaces::WalletTxStatus wtx;
             int numBlocks;
             int64_t block_time;
-            if (rec->statusUpdateNeeded(cur_num_blocks) &&
+            if (rec->statusUpdateNeeded(cur_block_hash) &&
                 wallet.tryGetTxStatus(rec->txid, wtx, numBlocks, block_time)) {
-                rec->updateStatus(wtx, numBlocks, block_time);
+                rec->updateStatus(wtx, cur_block_hash, numBlocks, block_time);
             }
             return rec;
         }
@@ -672,7 +672,8 @@
                                          const QModelIndex &parent) const {
     Q_UNUSED(parent);
     TransactionRecord *data =
-        priv->index(walletModel->wallet(), walletModel->getNumBlocks(), row);
+        priv->index(walletModel->wallet(),
+                    walletModel->clientModel().getBestBlockHash(), row);
     if (data) {
         return createIndex(row, column, data);
     }
diff --git a/src/qt/walletmodel.h b/src/qt/walletmodel.h
--- a/src/qt/walletmodel.h
+++ b/src/qt/walletmodel.h
@@ -148,8 +148,8 @@
 
     interfaces::Node &node() const { return m_node; }
     interfaces::Wallet &wallet() const { return *m_wallet; }
+    ClientModel &clientModel() const { return *m_client_model; }
     void setClientModel(ClientModel *client_model);
-    int getNumBlocks() const { return cachedNumBlocks; }
 
     const CChainParams &getChainParams() const;
 
@@ -188,9 +188,11 @@
     // Cache some values to be able to detect changes
     interfaces::WalletBalances m_cached_balances;
     EncryptionStatus cachedEncryptionStatus;
-    int cachedNumBlocks;
     QTimer *timer;
 
+    // Block hash denoting when the last balance update was done.
+    BlockHash m_cached_last_update_tip{};
+
     void subscribeToCoreSignals();
     void unsubscribeFromCoreSignals();
     void checkBalanceChanged(const interfaces::WalletBalances &new_balances);
diff --git a/src/qt/walletmodel.cpp b/src/qt/walletmodel.cpp
--- a/src/qt/walletmodel.cpp
+++ b/src/qt/walletmodel.cpp
@@ -34,8 +34,7 @@
       m_client_model(&client_model), m_node(client_model.node()),
       optionsModel(client_model.getOptionsModel()), addressTableModel(nullptr),
       transactionTableModel(nullptr), recentRequestsTableModel(nullptr),
-      cachedEncryptionStatus(Unencrypted), cachedNumBlocks(0),
-      timer(new QTimer(this)) {
+      cachedEncryptionStatus(Unencrypted), timer(new QTimer(this)) {
     fHaveWatchOnly = m_wallet->haveWatchOnly();
     addressTableModel = new AddressTableModel(this);
     transactionTableModel = new TransactionTableModel(platformStyle, this);
@@ -73,7 +72,7 @@
     // Avoid recomputing wallet balances unless a TransactionChanged or
     // BlockTip notification was received.
     if (!fForceCheckBalanceChanged &&
-        cachedNumBlocks == m_client_model->getNumBlocks()) {
+        m_cached_last_update_tip == m_client_model->getBestBlockHash()) {
         return;
     }
 
@@ -82,16 +81,16 @@
     // holding the locks for a longer time - for example, during a wallet
     // rescan.
     interfaces::WalletBalances new_balances;
-    int numBlocks = -1;
-    if (!m_wallet->tryGetBalances(new_balances, numBlocks)) {
+    BlockHash block_hash;
+    if (!m_wallet->tryGetBalances(new_balances, block_hash)) {
         return;
     }
 
-    if (fForceCheckBalanceChanged || numBlocks != cachedNumBlocks) {
+    if (fForceCheckBalanceChanged || block_hash != m_cached_last_update_tip) {
         fForceCheckBalanceChanged = false;
 
         // Balance and number of transactions might have changed
-        cachedNumBlocks = numBlocks;
+        m_cached_last_update_tip = block_hash;
 
         checkBalanceChanged(new_balances);
         if (transactionTableModel) {