diff --git a/src/Makefile.qt.include b/src/Makefile.qt.include
index 095cf7ce2353..03f2d12827ba 100644
--- a/src/Makefile.qt.include
+++ b/src/Makefile.qt.include
@@ -23,7 +23,6 @@ QT_FORMS_UI = \
   qt/forms/debugwindow.ui \
   qt/forms/descriptiondialog.ui \
   qt/forms/editaddressdialog.ui \
-  qt/forms/governancelist.ui \
   qt/forms/helpmessagedialog.ui \
   qt/forms/intro.ui \
   qt/forms/masternodelist.ui \
@@ -33,6 +32,7 @@ QT_FORMS_UI = \
   qt/forms/optionsdialog.ui \
   qt/forms/overviewpage.ui \
   qt/forms/proposalcreate.ui \
+  qt/forms/proposallist.ui \
   qt/forms/proposalresume.ui \
   qt/forms/psbtoperationsdialog.ui \
   qt/forms/qrdialog.ui \
@@ -53,6 +53,7 @@ QT_MOC_CPP = \
   qt/moc_bitcoinamountfield.cpp \
   qt/moc_bitcoingui.cpp \
   qt/moc_bitcoinunits.cpp \
+  qt/moc_clientfeeds.cpp \
   qt/moc_clientmodel.cpp \
   qt/moc_coincontroldialog.cpp \
   qt/moc_coincontroltreewidget.cpp \
@@ -60,7 +61,6 @@ QT_MOC_CPP = \
   qt/moc_csvmodelwriter.cpp \
   qt/moc_descriptiondialog.cpp \
   qt/moc_editaddressdialog.cpp \
-  qt/moc_governancelist.cpp \
   qt/moc_guiutil.cpp \
   qt/moc_initexecutor.cpp \
   qt/moc_intro.cpp \
@@ -78,8 +78,9 @@ QT_MOC_CPP = \
   qt/moc_paymentserver.cpp \
   qt/moc_peertablemodel.cpp \
   qt/moc_peertablesortproxy.cpp \
-  qt/moc_proposalmodel.cpp \
   qt/moc_proposalcreate.cpp \
+  qt/moc_proposallist.cpp \
+  qt/moc_proposalmodel.cpp \
   qt/moc_proposalresume.cpp \
   qt/moc_psbtoperationsdialog.cpp \
   qt/moc_qrdialog.cpp \
@@ -133,6 +134,7 @@ BITCOIN_QT_H = \
   qt/bitcoinamountfield.h \
   qt/bitcoingui.h \
   qt/bitcoinunits.h \
+  qt/clientfeeds.h \
   qt/clientmodel.h \
   qt/coincontroldialog.h \
   qt/coincontroltreewidget.h \
@@ -140,10 +142,9 @@ BITCOIN_QT_H = \
   qt/csvmodelwriter.h \
   qt/descriptiondialog.h \
   qt/editaddressdialog.h \
-  qt/governancelist.h \
   qt/guiconstants.h \
-  qt/guiutil.h \
   qt/guiutil_font.h \
+  qt/guiutil.h \
   qt/initexecutor.h \
   qt/intro.h \
   qt/macdockiconhandler.h \
@@ -163,6 +164,7 @@ BITCOIN_QT_H = \
   qt/peertablemodel.h \
   qt/peertablesortproxy.h \
   qt/proposalcreate.h \
+  qt/proposallist.h \
   qt/proposalmodel.h \
   qt/proposalresume.h \
   qt/psbtoperationsdialog.h \
@@ -242,9 +244,12 @@ BITCOIN_QT_BASE_CPP = \
   qt/bantablemodel.cpp \
   qt/bitcoin.cpp \
   qt/bitcoinaddressvalidator.cpp \
+  qt/masternodemodel.cpp \
+  qt/proposalmodel.cpp \
   qt/bitcoinamountfield.cpp \
   qt/bitcoingui.cpp \
   qt/bitcoinunits.cpp \
+  qt/clientfeeds.cpp \
   qt/clientmodel.cpp \
   qt/csvmodelwriter.cpp \
   qt/guiutil.cpp \
@@ -277,15 +282,13 @@ BITCOIN_QT_WALLET_CPP = \
   qt/createwalletdialog.cpp \
   qt/descriptiondialog.cpp \
   qt/editaddressdialog.cpp \
-  qt/governancelist.cpp \
   qt/masternodelist.cpp \
-  qt/masternodemodel.cpp \
   qt/mnemonicverificationdialog.cpp \
   qt/openuridialog.cpp \
   qt/overviewpage.cpp \
   qt/paymentserver.cpp \
   qt/proposalcreate.cpp \
-  qt/proposalmodel.cpp \
+  qt/proposallist.cpp \
   qt/proposalresume.cpp \
   qt/psbtoperationsdialog.cpp \
   qt/qrdialog.cpp \
diff --git a/src/qt/bitcoingui.cpp b/src/qt/bitcoingui.cpp
index 256aec68f65d..518ba44f2df6 100644
--- a/src/qt/bitcoingui.cpp
+++ b/src/qt/bitcoingui.cpp
@@ -5,18 +5,31 @@
 
 #include <qt/bitcoingui.h>
 
+#include <chain.h>
+#include <chainparams.h>
+#include <interfaces/coinjoin.h>
+#include <interfaces/handler.h>
+#include <interfaces/node.h>
+#include <node/interface_ui.h>
+#include <util/system.h>
+#include <util/translation.h>
+#include <util/underlying.h>
+#include <validation.h>
+
 #include <qt/bitcoinunits.h>
 #include <qt/clientmodel.h>
 #include <qt/createwalletdialog.h>
 #include <qt/guiconstants.h>
-#include <qt/guiutil.h>
 #include <qt/guiutil_font.h>
+#include <qt/guiutil.h>
+#include <qt/masternodelist.h>
 #include <qt/modaloverlay.h>
 #include <qt/networkstyle.h>
 #include <qt/notificator.h>
 #include <qt/openuridialog.h>
 #include <qt/optionsdialog.h>
 #include <qt/optionsmodel.h>
+#include <qt/proposallist.h>
 #include <qt/rpcconsole.h>
 #include <qt/utilitydialog.h>
 
@@ -31,20 +44,6 @@
 #include <qt/macdockiconhandler.h>
 #endif
 
-#include <functional>
-#include <chain.h>
-#include <chainparams.h>
-#include <interfaces/coinjoin.h>
-#include <interfaces/handler.h>
-#include <interfaces/node.h>
-#include <node/interface_ui.h>
-#include <qt/governancelist.h>
-#include <qt/masternodelist.h>
-#include <util/system.h>
-#include <util/translation.h>
-#include <util/underlying.h>
-#include <validation.h>
-
 #include <QAction>
 #include <QActionGroup>
 #include <QApplication>
@@ -72,6 +71,8 @@
 #include <QVBoxLayout>
 #include <QWindow>
 
+#include <functional>
+
 namespace {
 // Total governance clock frames. Frame 0 is reserved for the superblock
 // maturity window; frames 1 through GOV_CYCLE_FRAME_COUNT-1 are used for the
diff --git a/src/qt/clientfeeds.cpp b/src/qt/clientfeeds.cpp
new file mode 100644
index 000000000000..a50fedaaf654
--- /dev/null
+++ b/src/qt/clientfeeds.cpp
@@ -0,0 +1,235 @@
+// Copyright (c) 2026 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <qt/clientfeeds.h>
+
+#include <coins.h>
+#include <key_io.h>
+#include <script/standard.h>
+#include <util/threadnames.h>
+#include <util/time.h>
+
+#include <qt/clientmodel.h>
+#include <qt/masternodemodel.h>
+#include <qt/proposalmodel.h>
+
+#include <QDebug>
+#include <QThread>
+
+namespace {
+constexpr auto MASTERNODE_UPDATE_INTERVAL{3s};
+constexpr auto PROPOSAL_UPDATE_INTERVAL{10s};
+} // anonymous namespace
+
+FeedBase::FeedBase(QObject* parent, const FeedBase::Config& config) :
+    QObject{parent},
+    m_config{config}
+{
+}
+
+FeedBase::~FeedBase() = default;
+
+void FeedBase::requestForceRefresh()
+{
+    if (m_timer) {
+        m_timer->start(0);
+    }
+}
+
+void FeedBase::requestRefresh()
+{
+    if (m_timer && !m_timer->isActive()) {
+        m_timer->start(m_syncing.load() ? m_config.m_throttle : m_config.m_baseline);
+    }
+}
+
+MasternodeFeed::MasternodeFeed(QObject* parent, ClientModel& client_model) :
+    Feed<MasternodeData>{parent, {/*m_baseline=*/MASTERNODE_UPDATE_INTERVAL, /*m_throttle=*/MASTERNODE_UPDATE_INTERVAL*10}},
+    m_client_model{client_model}
+{
+}
+
+MasternodeFeed::~MasternodeFeed() = default;
+
+void MasternodeFeed::fetch()
+{
+    if (m_client_model.node().shutdownRequested()) {
+        return;
+    }
+
+    const auto [dmn, pindex] = m_client_model.getMasternodeList();
+    if (!dmn || !pindex) {
+        return;
+    }
+
+    auto projectedPayees = dmn->getProjectedMNPayees(pindex);
+    if (projectedPayees.empty() && dmn->getValidMNsCount() > 0) {
+        // GetProjectedMNPayees failed to provide results for a list with valid mns.
+        // Keep current list and let it try again later.
+        return;
+    }
+
+    auto ret = std::make_shared<Data>();
+    ret->m_list_height = dmn->getHeight();
+
+    Uint256HashMap<int> nextPayments;
+    for (size_t i = 0; i < projectedPayees.size(); i++) {
+        const auto& dmn = projectedPayees[i];
+        nextPayments.emplace(dmn->getProTxHash(), ret->m_list_height + (int)i + 1);
+    }
+
+    dmn->forEachMN(/*only_valid=*/false, [&](const auto& dmn) {
+        CTxDestination collateralDest;
+        Coin coin;
+        QString collateralStr = QObject::tr("UNKNOWN");
+        if (m_client_model.node().getUnspentOutput(dmn.getCollateralOutpoint(), coin) &&
+            ExtractDestination(coin.out.scriptPubKey, collateralDest)) {
+            collateralStr = QString::fromStdString(EncodeDestination(collateralDest));
+        }
+        int nNextPayment{0};
+        if (auto nextPaymentIt = nextPayments.find(dmn.getProTxHash()); nextPaymentIt != nextPayments.end()) {
+            nNextPayment = nextPaymentIt->second;
+        }
+        ret->m_entries.push_back(std::make_unique<MasternodeEntry>(dmn, collateralStr, nNextPayment));
+    });
+
+    ret->m_valid = true;
+    setData(std::move(ret));
+}
+
+ProposalFeed::ProposalFeed(QObject* parent, ClientModel& client_model) :
+    Feed<ProposalData>{parent, {/*m_baseline=*/PROPOSAL_UPDATE_INTERVAL, /*m_throttle=*/PROPOSAL_UPDATE_INTERVAL*6}},
+    m_client_model{client_model}
+{
+}
+
+ProposalFeed::~ProposalFeed() = default;
+
+void ProposalFeed::fetch()
+{
+    if (m_client_model.node().shutdownRequested()) {
+        return;
+    }
+
+    const auto [dmn, pindex] = m_client_model.getMasternodeList();
+    if (!dmn || !pindex) {
+        return;
+    }
+
+    auto ret = std::make_shared<Data>();
+    // A proposal is considered passing if (YES votes - NO votes) >= (Total Weight of Masternodes / 10),
+    // count total valid (ENABLED) masternodes to determine passing threshold.
+    // Need to query number of masternodes here with access to client model.
+    const int nWeightedMnCount = dmn->getValidWeightedMNsCount();
+    ret->m_abs_vote_req = std::max(Params().GetConsensus().nGovernanceMinQuorum, nWeightedMnCount / 10);
+    ret->m_gov_info = m_client_model.node().gov().getGovernanceInfo();
+    std::vector<CGovernanceObject> govObjList;
+    m_client_model.getAllGovernanceObjects(govObjList);
+    for (const auto& govObj : govObjList) {
+        if (govObj.GetObjectType() != GovernanceObject::PROPOSAL) {
+            continue; // Skip triggers.
+        }
+        ret->m_proposals.emplace_back(std::make_shared<Proposal>(m_client_model, govObj, ret->m_gov_info, ret->m_gov_info.requiredConfs,
+                                                                 /*is_broadcast=*/true));
+    }
+
+    auto fundable{m_client_model.node().gov().getFundableProposalHashes()};
+    ret->m_fundable_hashes = std::move(fundable.hashes);
+
+    setData(std::move(ret));
+}
+
+ClientFeeds::ClientFeeds(QObject* parent) :
+    QObject{parent},
+    m_thread{new QThread(this)}
+{
+}
+
+ClientFeeds::~ClientFeeds()
+{
+    stop();
+}
+
+void ClientFeeds::registerFeed(FeedBase* raw)
+{
+    auto* timer = new QTimer(this);
+    timer->setSingleShot(true);
+    raw->m_timer = timer;
+
+    connect(timer, &QTimer::timeout, this, [this, raw] {
+        if (raw->m_in_progress.exchange(true)) {
+            raw->m_retry_pending.store(true);
+            return;
+        }
+        QMetaObject::invokeMethod(m_worker, [this, raw] {
+            try {
+                raw->fetch();
+            } catch (const std::exception& e) {
+                qWarning() << "ClientFeeds::fetch() exception: " << e.what();
+            } catch (...) {
+                qWarning() << "ClientFeeds::fetch() unknown exception";
+            }
+            QTimer::singleShot(0, raw, [this, raw] {
+                raw->m_in_progress.store(false);
+                if (m_stopped) return;
+                Q_EMIT raw->dataReady();
+                if (raw->m_retry_pending.exchange(false)) {
+                    raw->requestRefresh();
+                }
+            });
+        });
+    });
+}
+
+void ClientFeeds::start()
+{
+    m_worker = new QObject();
+    m_worker->moveToThread(m_thread);
+    m_thread->start();
+    QMetaObject::invokeMethod(m_worker, [] { util::ThreadRename("qt-clientfeed"); });
+
+    for (const auto& source : m_sources) {
+        if (source->m_timer) {
+            source->m_timer->start(0);
+        }
+    }
+}
+
+void ClientFeeds::stop()
+{
+    if (m_stopped) {
+        return;
+    }
+
+    m_stopped = true;
+    for (const auto& source : m_sources) {
+        if (source->m_timer) {
+            source->m_timer->stop();
+            source->m_timer = nullptr;
+        }
+    }
+    if (m_thread->isRunning()) {
+        m_thread->quit();
+        m_thread->wait();
+    }
+    delete m_worker;
+    m_worker = nullptr;
+}
+
+void ClientFeeds::setSyncing(bool syncing)
+{
+    if (m_stopped) {
+        return;
+    }
+
+    for (const auto& source : m_sources) {
+        if (source->m_syncing.load() == syncing) {
+            continue;
+        }
+        source->setSyncing(syncing);
+        if (source->m_timer && source->m_timer->isActive()) {
+            source->m_timer->start(syncing ? source->m_config.m_throttle : source->m_config.m_baseline);
+        }
+    }
+}
diff --git a/src/qt/clientfeeds.h b/src/qt/clientfeeds.h
new file mode 100644
index 000000000000..cc79c54bb08e
--- /dev/null
+++ b/src/qt/clientfeeds.h
@@ -0,0 +1,170 @@
+// Copyright (c) 2026 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_QT_CLIENTFEEDS_H
+#define BITCOIN_QT_CLIENTFEEDS_H
+
+#include <interfaces/node.h>
+#include <saltedhasher.h>
+#include <sync.h>
+#include <threadsafety.h>
+
+#include <QObject>
+#include <QTimer>
+
+#include <atomic>
+#include <cassert>
+#include <memory>
+#include <vector>
+
+QT_BEGIN_NAMESPACE
+class QThread;
+QT_END_NAMESPACE
+
+class ClientModel;
+class MasternodeEntry;
+class Proposal;
+
+class FeedBase : public QObject
+{
+    Q_OBJECT
+
+    friend class ClientFeeds;
+
+public:
+    struct Config {
+        std::chrono::milliseconds m_baseline;
+        std::chrono::milliseconds m_throttle;
+    };
+
+    explicit FeedBase(QObject* parent, const Config& config);
+    virtual ~FeedBase();
+
+    void setSyncing(bool syncing) { m_syncing.store(syncing); }
+    const Config& config() const { return m_config; }
+
+    virtual void fetch() = 0;
+    void requestForceRefresh();
+    void requestRefresh();
+
+Q_SIGNALS:
+    void dataReady();
+
+protected:
+    Config m_config;
+    QTimer* m_timer{nullptr};
+    std::atomic<bool> m_in_progress{false};
+    std::atomic<bool> m_retry_pending{false};
+    std::atomic<bool> m_syncing{true};
+};
+
+template<typename T>
+class Feed : public FeedBase
+{
+public:
+    using Data = T;
+
+    explicit Feed(QObject* parent, const Config& config) :
+        FeedBase{parent, config}
+    {
+    }
+    ~Feed() override = default;
+
+    std::shared_ptr<const Data> data() const EXCLUSIVE_LOCKS_REQUIRED(!m_cs)
+    {
+        LOCK(m_cs);
+        return m_data;
+    }
+
+    // FeedBase
+    void fetch() override EXCLUSIVE_LOCKS_REQUIRED(!m_cs) = 0;
+
+protected:
+    void setData(std::shared_ptr<const Data> data) EXCLUSIVE_LOCKS_REQUIRED(!m_cs)
+    {
+        LOCK(m_cs);
+        m_data = std::move(data);
+    }
+
+private:
+    mutable Mutex m_cs;
+    std::shared_ptr<const Data> m_data GUARDED_BY(m_cs);
+};
+
+using MasternodeEntryList = std::vector<std::shared_ptr<MasternodeEntry>>;
+
+struct MasternodeData {
+    bool m_valid{false};
+    int m_list_height{0};
+    MasternodeEntryList m_entries;
+};
+
+class MasternodeFeed : public Feed<MasternodeData> {
+    Q_OBJECT
+
+public:
+    explicit MasternodeFeed(QObject* parent, ClientModel& client_model);
+    ~MasternodeFeed();
+
+    void fetch() override;
+
+private:
+    ClientModel& m_client_model;
+};
+
+using Proposals = std::vector<std::shared_ptr<Proposal>>;
+
+struct ProposalData {
+    int m_abs_vote_req{0};
+    interfaces::GOV::GovernanceInfo m_gov_info;
+    Proposals m_proposals;
+    Uint256HashSet m_fundable_hashes;
+};
+
+class ProposalFeed : public Feed<ProposalData> {
+    Q_OBJECT
+
+public:
+    explicit ProposalFeed(QObject* parent, ClientModel& client_model);
+    ~ProposalFeed();
+
+    void fetch() override;
+
+private:
+    ClientModel& m_client_model;
+};
+
+class ClientFeeds : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit ClientFeeds(QObject* parent);
+    ~ClientFeeds();
+
+    template<typename Source, typename... Args>
+    Source* add(Args&&... args) {
+        assert(!m_stopped);
+        auto source = std::make_unique<Source>(std::forward<Args>(args)...);
+        Source* ptr = source.get();
+        registerFeed(ptr);
+        m_sources.push_back(std::move(source));
+        return ptr;
+    }
+
+    void setSyncing(bool syncing);
+    void start();
+    void stop();
+
+private:
+    void registerFeed(FeedBase* source);
+
+private:
+    bool m_stopped{false};
+    QObject* m_worker{nullptr};
+    QThread* m_thread{nullptr};
+    std::vector<std::unique_ptr<FeedBase>> m_sources{};
+};
+
+#endif // BITCOIN_QT_CLIENTFEEDS_H
diff --git a/src/qt/clientmodel.cpp b/src/qt/clientmodel.cpp
index 9afcc54c89a2..36596de32135 100644
--- a/src/qt/clientmodel.cpp
+++ b/src/qt/clientmodel.cpp
@@ -3,17 +3,21 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#if defined(HAVE_CONFIG_H)
+#include <config/bitcoin-config.h>
+#endif
+
 #include <qt/clientmodel.h>
 
 #include <qt/bantablemodel.h>
+#include <qt/clientfeeds.h>
 #include <qt/guiconstants.h>
 #include <qt/guiutil.h>
 #include <qt/peertablemodel.h>
 #include <qt/peertablesortproxy.h>
 
-#include <evo/deterministicmns.h>
-
 #include <clientversion.h>
+#include <evo/deterministicmns.h>
 #include <governance/object.h>
 #include <interfaces/handler.h>
 #include <interfaces/node.h>
@@ -24,7 +28,7 @@
 #include <util/time.h>
 #include <validation.h>
 
-#include <stdint.h>
+#include <cstdint>
 
 #include <QDebug>
 #include <QMetaObject>
@@ -67,6 +71,30 @@ ClientModel::ClientModel(interfaces::Node& node, OptionsModel *_optionsModel, QO
         util::ThreadRename("qt-clientmodl");
     });
 
+    // Setup data feed thread
+    m_feeds = std::make_unique<ClientFeeds>(this);
+
+    // Setup feeds
+    m_feed_masternode = m_feeds->add<MasternodeFeed>(this, *this);
+    connect(this, &ClientModel::masternodeListChanged, this, [this] { m_feed_masternode->requestRefresh(); });
+
+    if (m_node.gov().isEnabled()) {
+        m_feed_proposal = m_feeds->add<ProposalFeed>(this, *this);
+        connect(this, &ClientModel::governanceChanged, this, [this] { m_feed_proposal->requestRefresh(); });
+    }
+
+    // Update sync state to decide delay param, trigger refreshes
+    connect(this, &ClientModel::numBlocksChanged, this,
+        [this](int, const QDateTime&, const QString&, double, bool header, SynchronizationState sync_state) {
+            if (header) return;
+            m_feeds->setSyncing(sync_state != SynchronizationState::POST_INIT);
+            if (m_feed_masternode) m_feed_masternode->requestRefresh();
+            if (m_feed_proposal) m_feed_proposal->requestRefresh();
+        });
+
+    // Start all tasks
+    m_feeds->start();
+
     subscribeToCoreSignals();
 }
 
diff --git a/src/qt/clientmodel.h b/src/qt/clientmodel.h
index 279d49195ae3..6b08a1a014ea 100644
--- a/src/qt/clientmodel.h
+++ b/src/qt/clientmodel.h
@@ -7,32 +7,29 @@
 #define BITCOIN_QT_CLIENTMODEL_H
 
 #include <interfaces/node.h>
+#include <netaddress.h>
 #include <sync.h>
+#include <uint256.h>
 
 #include <QObject>
 #include <QDateTime>
 
 #include <atomic>
 #include <memory>
-#include <uint256.h>
-
-#include <netaddress.h>
 
 class BanTableModel;
 class CBlockIndex;
+class ClientFeeds;
+class MasternodeFeed;
 class OptionsModel;
 class PeerTableModel;
 class PeerTableSortProxy;
+class ProposalFeed;
 enum class SynchronizationState;
 struct LocalServiceInfo;
-
 namespace interfaces {
 struct BlockTip;
-}
-
-QT_BEGIN_NAMESPACE
-class QTimer;
-QT_END_NAMESPACE
+} // namespace interfaces
 
 enum class BlockSource {
     NONE,
@@ -68,6 +65,9 @@ class ClientModel : public QObject
     PeerTableSortProxy* peerTableSortProxy();
     BanTableModel *getBanTableModel();
 
+    MasternodeFeed* feedMasternode() const { return m_feed_masternode; }
+    ProposalFeed* feedProposal() const { return m_feed_proposal; }
+
     //! Return number of connections, default is in- and outbound (total)
     int getNumConnections(unsigned int flags = CONNECTIONS_ALL) const;
     std::map<CNetAddr, LocalServiceInfo> getNetLocalAddresses() const;
@@ -122,6 +122,11 @@ class ClientModel : public QObject
     interfaces::MnListPtr mnListCached GUARDED_BY(cs_mnlist){};
     const CBlockIndex* mnListTip{nullptr};
 
+    //! Data sources from different subsystems coordinated by model
+    MasternodeFeed* m_feed_masternode{nullptr};
+    ProposalFeed* m_feed_proposal{nullptr};
+    std::unique_ptr<ClientFeeds> m_feeds{nullptr};
+
     void TipChanged(SynchronizationState sync_state, interfaces::BlockTip tip, double verification_progress, bool header) EXCLUSIVE_LOCKS_REQUIRED(!m_cached_tip_mutex);
     void subscribeToCoreSignals();
     void unsubscribeFromCoreSignals();
diff --git a/src/qt/forms/governancelist.ui b/src/qt/forms/proposallist.ui
similarity index 98%
rename from src/qt/forms/governancelist.ui
rename to src/qt/forms/proposallist.ui
index 73e4803509e0..67ee680f0a5b 100644
--- a/src/qt/forms/governancelist.ui
+++ b/src/qt/forms/proposallist.ui
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
- <class>GovernanceList</class>
- <widget class="QWidget" name="GovernanceList">
+ <class>ProposalList</class>
+ <widget class="QWidget" name="ProposalList">
   <property name="geometry">
    <rect>
     <x>0</x>
diff --git a/src/qt/masternodelist.cpp b/src/qt/masternodelist.cpp
index 7db659a44ddd..619506dd945c 100644
--- a/src/qt/masternodelist.cpp
+++ b/src/qt/masternodelist.cpp
@@ -10,6 +10,7 @@
 #include <evo/dmn_types.h>
 #include <saltedhasher.h>
 
+#include <qt/clientfeeds.h>
 #include <qt/clientmodel.h>
 #include <qt/descriptiondialog.h>
 #include <qt/guiutil.h>
@@ -18,6 +19,7 @@
 
 #include <QApplication>
 #include <QClipboard>
+#include <QDebug>
 #include <QHeaderView>
 #include <QMetaObject>
 #include <QSettings>
@@ -25,10 +27,6 @@
 
 #include <set>
 
-namespace {
-constexpr int MASTERNODELIST_UPDATE_SECONDS{3};
-} // anonymous namespace
-
 bool MasternodeListSortFilterProxyModel::filterAcceptsRow(int source_row, const QModelIndex& source_parent) const
 {
     // "Type" filter
@@ -89,10 +87,7 @@ MasternodeList::MasternodeList(QWidget* parent) :
     QWidget(parent),
     ui(new Ui::MasternodeList),
     m_proxy_model(new MasternodeListSortFilterProxyModel(this)),
-    m_model(new MasternodeModel(this)),
-    m_worker(new QObject),
-    m_thread{new QThread(this)},
-    m_timer{new QTimer(this)}
+    m_model(new MasternodeModel(this))
 {
     ui->setupUi(this);
 
@@ -143,16 +138,6 @@ MasternodeList::MasternodeList(QWidget* parent) :
 
     GUIUtil::updateFonts();
 
-    // Background thread for calculating masternode list
-    m_worker->moveToThread(m_thread);
-    // Make sure executor object is deleted in its own thread
-    connect(m_thread, &QThread::finished, m_worker, &QObject::deleteLater);
-    m_thread->start();
-
-    // Debounce timer to apply masternode list changes
-    m_timer->setSingleShot(true);
-    connect(m_timer, &QTimer::timeout, this, &MasternodeList::updateDIP3ListScheduled);
-
     // Load filter settings
     QSettings settings;
     ui->checkBoxHideBanned->setChecked(settings.value("mnListHideBanned", false).toBool());
@@ -162,9 +147,6 @@ MasternodeList::MasternodeList(QWidget* parent) :
 
 MasternodeList::~MasternodeList()
 {
-    m_timer->stop();
-    m_thread->quit();
-    m_thread->wait();
     delete ui;
 }
 
@@ -179,11 +161,13 @@ void MasternodeList::changeEvent(QEvent* event)
 void MasternodeList::setClientModel(ClientModel* model)
 {
     this->clientModel = model;
-    if (model) {
-        connect(clientModel, &ClientModel::masternodeListChanged, this, &MasternodeList::handleMasternodeListChanged);
-        m_timer->start(0);
-    } else {
-        m_timer->stop();
+    if (!clientModel) {
+        return;
+    }
+    m_feed = clientModel->feedMasternode();
+    if (m_feed) {
+        connect(m_feed, &MasternodeFeed::dataReady, this, &MasternodeList::updateMasternodeList);
+        updateMasternodeList();
     }
 }
 
@@ -205,128 +189,63 @@ void MasternodeList::showContextMenuDIP3(const QPoint& point)
     }
 }
 
-void MasternodeList::handleMasternodeListChanged()
+void MasternodeList::updateMasternodeList()
 {
-    if (!clientModel || m_timer->isActive()) {
-        // Too early or already processing, nothing to do
+    if (!clientModel || !m_feed) {
         return;
     }
 
-    int delay{MASTERNODELIST_UPDATE_SECONDS * 1000};
-    if (!clientModel->masternodeSync().isBlockchainSynced()) {
-        // Currently syncing, reduce refreshes
-        delay *= 10;
-    }
-    m_timer->start(delay);
-}
-
-void MasternodeList::updateDIP3ListScheduled()
-{
-    if (!clientModel || clientModel->node().shutdownRequested()) {
+    auto feed = m_feed->data();
+    if (!feed) {
         return;
     }
 
-    if (m_in_progress.exchange(true)) {
-        // Already applying, re-arm for next attempt
-        handleMasternodeListChanged();
+    if (!feed->m_valid) {
+        qWarning() << "MasternodeList: fetch returned invalid data, scheduling retry";
+        m_feed->requestRefresh();
         return;
     }
 
-    QMetaObject::invokeMethod(m_worker, [this] {
-        auto result = std::make_shared<CalcMnList>(calcMasternodeList());
-        m_in_progress.store(false);
-        QTimer::singleShot(0, this, [this, result] {
-            if (result->m_valid) {
-                setMasternodeList(std::move(*result));
-            } else {
-                // Something went wrong, try again
-                handleMasternodeListChanged();
-            }
-        });
-    });
-}
-
-MasternodeList::CalcMnList MasternodeList::calcMasternodeList() const
-{
-    CalcMnList ret;
-    if (!clientModel || clientModel->node().shutdownRequested()) {
-        return ret;
-    }
+    MasternodeData ret;
+    ret.m_list_height = feed->m_list_height;
+    ret.m_entries = feed->m_entries;
+    ret.m_valid = feed->m_valid;
 
-    auto [mnList, pindex] = clientModel->getMasternodeList();
-    if (!pindex) return ret;
-    auto projectedPayees = mnList->getProjectedMNPayees(pindex);
-
-    if (projectedPayees.empty() && mnList->getValidMNsCount() > 0) {
-        // GetProjectedMNPayees failed to provide results for a list with valid mns.
-        // Keep current list and let it try again later.
-        return ret;
+    // If we don't have a wallet, nothing else to do...
+    if (!walletModel) {
+        setMasternodeList(std::move(ret), {});
+        return;
     }
 
-    ret.m_list_height = mnList->getHeight();
-
-    Uint256HashMap<CTxDestination> mapCollateralDests;
-    mnList->forEachMN(/*only_valid=*/false, [&](const auto& dmn) {
-        CTxDestination collateralDest;
-        Coin coin;
-        if (clientModel->node().getUnspentOutput(dmn.getCollateralOutpoint(), coin) &&
-            ExtractDestination(coin.out.scriptPubKey, collateralDest)) {
-            mapCollateralDests.emplace(dmn.getProTxHash(), collateralDest);
-        }
-    });
-
-    Uint256HashMap<int> nextPayments;
-    for (size_t i = 0; i < projectedPayees.size(); i++) {
-        const auto& dmn = projectedPayees[i];
-        nextPayments.emplace(dmn->getProTxHash(), ret.m_list_height + (int)i + 1);
+    std::set<COutPoint> setOutpts;
+    for (const auto& outpt : walletModel->wallet().listProTxCoins()) {
+        setOutpts.emplace(outpt);
     }
 
-    mnList->forEachMN(/*only_valid=*/false, [&](const auto& dmn) {
-        QString collateralStr = QObject::tr("UNKNOWN");
-        auto collateralDestIt = mapCollateralDests.find(dmn.getProTxHash());
-        if (collateralDestIt != mapCollateralDests.end()) {
-            collateralStr = QString::fromStdString(EncodeDestination(collateralDestIt->second));
-        }
-
-        int nNextPayment = 0;
-        auto nextPaymentIt = nextPayments.find(dmn.getProTxHash());
-        if (nextPaymentIt != nextPayments.end()) {
-            nNextPayment = nextPaymentIt->second;
-        }
-
-        ret.m_entries.push_back(std::make_unique<MasternodeEntry>(dmn, collateralStr, nNextPayment));
-    });
-
-    // Compute "owned" masternode hashes for the filter
-    if (walletModel) {
-        std::set<COutPoint> setOutpts;
-        for (const auto& outpt : walletModel->wallet().listProTxCoins()) {
-            setOutpts.emplace(outpt);
-        }
-
-        mnList->forEachMN(/*only_valid=*/false, [&](const auto& dmn) {
+    QSet<QString> owned_mns;
+    const auto [dmn, pindex] = clientModel->getMasternodeList();
+    if (dmn && pindex) {
+        dmn->forEachMN(/*only_valid=*/false, [&](const auto& dmn) {
             bool fMyMasternode = setOutpts.count(dmn.getCollateralOutpoint()) ||
-                                 walletModel->wallet().isSpendable(PKHash(dmn.getKeyIdOwner())) ||
-                                 walletModel->wallet().isSpendable(PKHash(dmn.getKeyIdVoting())) ||
-                                 walletModel->wallet().isSpendable(dmn.getScriptPayout()) ||
-                                 walletModel->wallet().isSpendable(dmn.getScriptOperatorPayout());
+                                walletModel->wallet().isSpendable(PKHash(dmn.getKeyIdOwner())) ||
+                                walletModel->wallet().isSpendable(PKHash(dmn.getKeyIdVoting())) ||
+                                walletModel->wallet().isSpendable(dmn.getScriptPayout()) ||
+                                walletModel->wallet().isSpendable(dmn.getScriptOperatorPayout());
             if (fMyMasternode) {
-                ret.m_owned_mns.insert(QString::fromStdString(dmn.getProTxHash().ToString()));
+                owned_mns.insert(QString::fromStdString(dmn.getProTxHash().ToString()));
             }
         });
     }
-
-    ret.m_valid = true;
-    return ret;
+    setMasternodeList(std::move(ret), std::move(owned_mns));
 }
 
-void MasternodeList::setMasternodeList(CalcMnList&& list)
+void MasternodeList::setMasternodeList(MasternodeData&& list, QSet<QString>&& owned_mns)
 {
     m_model->setCurrentHeight(list.m_list_height);
     m_model->reconcile(std::move(list.m_entries));
 
     if (walletModel) {
-        m_proxy_model->setMyMasternodeHashes(std::move(list.m_owned_mns));
+        m_proxy_model->setMyMasternodeHashes(std::move(owned_mns));
         if (ui->checkBoxOwned->isChecked()) {
             m_proxy_model->forceInvalidateFilter();
         }
diff --git a/src/qt/masternodelist.h b/src/qt/masternodelist.h
index cffe4cc0b0d5..ffbd4fb8fe09 100644
--- a/src/qt/masternodelist.h
+++ b/src/qt/masternodelist.h
@@ -17,6 +17,10 @@
 #include <atomic>
 #include <memory>
 
+class ClientModel;
+class MasternodeFeed;
+class WalletModel;
+struct MasternodeData;
 namespace interfaces {
 class MnList;
 using MnListPtr = std::shared_ptr<MnList>;
@@ -25,12 +29,9 @@ namespace Ui {
 class MasternodeList;
 } // namespace Ui
 
-class ClientModel;
-class QThread;
-class WalletModel;
-
 QT_BEGIN_NAMESPACE
 class QModelIndex;
+class QThread;
 QT_END_NAMESPACE
 
 class MasternodeListSortFilterProxyModel : public QSortFilterProxyModel
@@ -83,25 +84,14 @@ class MasternodeList : public QWidget
     void changeEvent(QEvent* event) override;
 
 private:
-    struct CalcMnList {
-        int m_list_height{0};
-        MasternodeEntryList m_entries;
-        QSet<QString> m_owned_mns;
-        bool m_valid{false};
-    };
-
     ClientModel* clientModel{nullptr};
+    MasternodeFeed* m_feed{nullptr};
     MasternodeListSortFilterProxyModel* m_proxy_model{nullptr};
     MasternodeModel* m_model{nullptr};
     QMenu* contextMenuDIP3{nullptr};
-    QObject* m_worker{nullptr};
-    QThread* m_thread{nullptr};
-    QTimer* m_timer{nullptr};
-    std::atomic<bool> m_in_progress{false};
     WalletModel* walletModel{nullptr};
 
-    CalcMnList calcMasternodeList() const;
-    void setMasternodeList(CalcMnList&& data);
+    void setMasternodeList(MasternodeData&& data, QSet<QString>&& owned_mns);
 
     const MasternodeEntry* GetSelectedEntry();
 
@@ -113,17 +103,16 @@ private Q_SLOTS:
     void copyProTxHash_clicked();
     void extraInfoDIP3_clicked();
     void filterByCollateralAddress();
-    void filterByPayoutAddress();
     void filterByOwnerAddress();
+    void filterByPayoutAddress();
     void filterByVotingAddress();
-    void handleMasternodeListChanged();
     void on_checkBoxHideBanned_stateChanged(int state);
     void on_checkBoxOwned_stateChanged(int state);
     void on_comboBoxType_currentIndexChanged(int index);
     void on_filterText_textChanged(const QString& strFilterIn);
     void showContextMenuDIP3(const QPoint&);
-    void updateDIP3ListScheduled();
     void updateFilteredCount();
+    void updateMasternodeList();
 };
 
 #endif // BITCOIN_QT_MASTERNODELIST_H
diff --git a/src/qt/masternodemodel.cpp b/src/qt/masternodemodel.cpp
index 39477c1f1795..ea613bfec4e2 100644
--- a/src/qt/masternodemodel.cpp
+++ b/src/qt/masternodemodel.cpp
@@ -351,7 +351,7 @@ QVariant MasternodeModel::headerData(int section, Qt::Orientation orientation, i
     }
 }
 
-void MasternodeModel::append(std::unique_ptr<MasternodeEntry>&& entry)
+void MasternodeModel::append(std::shared_ptr<MasternodeEntry>&& entry)
 {
     beginInsertRows({}, rowCount(), rowCount());
     m_data.push_back(std::move(entry));
@@ -377,7 +377,7 @@ void MasternodeModel::reconcile(MasternodeEntryList&& entries)
 
     std::set<int> present;
     std::vector<int> changed;
-    std::vector<std::unique_ptr<MasternodeEntry>> add;
+    std::vector<std::shared_ptr<MasternodeEntry>> add;
     for (auto& entry : entries) {
         if (auto it = existing.find(entry->proTxHash()); it != existing.end()) {
             int idx = it.value();
diff --git a/src/qt/masternodemodel.h b/src/qt/masternodemodel.h
index 287117058109..c57792f222a1 100644
--- a/src/qt/masternodemodel.h
+++ b/src/qt/masternodemodel.h
@@ -86,7 +86,7 @@ class MasternodeEntry
     QString toHtml() const;
 };
 
-using MasternodeEntryList = std::vector<std::unique_ptr<MasternodeEntry>>;
+using MasternodeEntryList = std::vector<std::shared_ptr<MasternodeEntry>>;
 
 class MasternodeModel : public QAbstractTableModel
 {
@@ -124,7 +124,7 @@ class MasternodeModel : public QAbstractTableModel
     QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
     QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
 
-    void append(std::unique_ptr<MasternodeEntry>&& entry);
+    void append(std::shared_ptr<MasternodeEntry>&& entry);
     void remove(int row);
     void reconcile(MasternodeEntryList&& entries);
     void setCurrentHeight(int height) { m_current_height = height; }
diff --git a/src/qt/governancelist.cpp b/src/qt/proposallist.cpp
similarity index 71%
rename from src/qt/governancelist.cpp
rename to src/qt/proposallist.cpp
index 4fb7f2047105..fd5a08aa7d7a 100644
--- a/src/qt/governancelist.cpp
+++ b/src/qt/proposallist.cpp
@@ -2,28 +2,27 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <qt/forms/ui_governancelist.h>
+#include <qt/forms/ui_proposallist.h>
 
+#include <chainparams.h>
 #include <evo/deterministicmns.h>
 #include <governance/common.h>
 #include <governance/governance.h>
 #include <governance/vote.h>
+#include <interfaces/node.h>
+#include <interfaces/wallet.h>
+#include <script/standard.h>
+#include <util/strencodings.h>
 #include <util/underlying.h>
 
+#include <qt/clientfeeds.h>
 #include <qt/descriptiondialog.h>
-#include <qt/governancelist.h>
 #include <qt/guiutil_font.h>
 #include <qt/proposalcreate.h>
+#include <qt/proposallist.h>
 #include <qt/proposalmodel.h>
 #include <qt/proposalresume.h>
 
-#include <chainparams.h>
-#include <interfaces/node.h>
-#include <interfaces/wallet.h>
-#include <script/standard.h>
-#include <util/strencodings.h>
-#include <util/time.h>
-
 #include <qt/bitcoinunits.h>
 #include <qt/clientmodel.h>
 #include <qt/guiutil.h>
@@ -43,22 +42,18 @@
 
 #include <univalue.h>
 
+#include <algorithm>
+
 namespace {
 constexpr int TITLE_MIN_WIDTH{220};
 } // anonymous namespace
 
-//
-// Governance Tab main widget.
-//
-GovernanceList::GovernanceList(QWidget* parent) :
+ProposalList::ProposalList(QWidget* parent) :
     QWidget(parent),
-    ui{new Ui::GovernanceList},
+    ui{new Ui::ProposalList},
     proposalModel{new ProposalModel(this)},
     proposalContextMenu{new QMenu(this)},
-    m_worker(new QObject),
-    proposalModelProxy{new QSortFilterProxyModel(this)},
-    m_thread{new QThread(this)},
-    m_timer{new QTimer(this)}
+    proposalModelProxy{new QSortFilterProxyModel(this)}
 {
     ui->setupUi(this);
 
@@ -71,16 +66,16 @@ GovernanceList::GovernanceList(QWidget* parent) :
     ui->govTableView->setSortingEnabled(true);
     ui->govTableView->sortByColumn(ProposalModel::Column::TITLE, Qt::AscendingOrder);
     ui->govTableView->verticalHeader()->setVisible(false);
-    connect(ui->govTableView, &QTableView::customContextMenuRequested, this, &GovernanceList::showProposalContextMenu);
-    connect(ui->govTableView, &QTableView::doubleClicked, this, &GovernanceList::showAdditionalInfo);
-    connect(ui->govTableView->horizontalHeader(), &QHeaderView::sectionResized, this, &GovernanceList::refreshColumnWidths);
+    connect(ui->govTableView, &QTableView::customContextMenuRequested, this, &ProposalList::showProposalContextMenu);
+    connect(ui->govTableView, &QTableView::doubleClicked, this, &ProposalList::showAdditionalInfo);
+    connect(ui->govTableView->horizontalHeader(), &QHeaderView::sectionResized, this, &ProposalList::refreshColumnWidths);
 
     ui->emptyPage->setAutoFillBackground(true);
     updateEmptyPagePalette();
 
     ui->proposalSourceCombo->addItem(tr("Active Proposals"), ToUnderlying(ProposalSource::Active));
     ui->proposalSourceCombo->setMinimumWidth(250);
-    connect(ui->proposalSourceCombo, qOverload<int>(&QComboBox::activated), this, &GovernanceList::setProposalSource);
+    connect(ui->proposalSourceCombo, qOverload<int>(&QComboBox::activated), this, &ProposalList::setProposalSource);
 
     // Set up filtering.
     proposalModelProxy->setSourceModel(proposalModel);
@@ -89,73 +84,61 @@ GovernanceList::GovernanceList(QWidget* parent) :
     connect(ui->filterLineEdit, &QLineEdit::textChanged, proposalModelProxy, &QSortFilterProxyModel::setFilterFixedString);
 
     // Changes to number of rows should update proposal count display.
-    connect(proposalModelProxy, &QSortFilterProxyModel::rowsInserted, this, &GovernanceList::updateProposalCount);
-    connect(proposalModelProxy, &QSortFilterProxyModel::rowsRemoved, this, &GovernanceList::updateProposalCount);
-    connect(proposalModelProxy, &QSortFilterProxyModel::layoutChanged, this, &GovernanceList::updateProposalCount);
+    connect(proposalModelProxy, &QSortFilterProxyModel::rowsInserted, this, &ProposalList::updateProposalCount);
+    connect(proposalModelProxy, &QSortFilterProxyModel::rowsRemoved, this, &ProposalList::updateProposalCount);
+    connect(proposalModelProxy, &QSortFilterProxyModel::layoutChanged, this, &ProposalList::updateProposalCount);
 
     // Connect buttons
-    connect(ui->btnCreateProposal, &QPushButton::clicked, this, &GovernanceList::showCreateProposalDialog);
-    connect(ui->btnResumeProposal, &QPushButton::clicked, this, &GovernanceList::showResumeProposalDialog);
+    connect(ui->btnCreateProposal, &QPushButton::clicked, this, &ProposalList::showCreateProposalDialog);
+    connect(ui->btnResumeProposal, &QPushButton::clicked, this, &ProposalList::showResumeProposalDialog);
     updateProposalButtons();
 
     // Initialize masternode count to 0
     ui->mnCountLabel->setText("0");
 
     GUIUtil::updateFonts();
-
-    // Background thread for calculating proposal list
-    m_worker->moveToThread(m_thread);
-    // Make sure executor object is deleted in its own thread
-    connect(m_thread, &QThread::finished, m_worker, &QObject::deleteLater);
-    m_thread->start();
-
-    // Debounce timer to apply proposal list changes
-    m_timer->setSingleShot(true);
-    connect(m_timer, &QTimer::timeout, this, &GovernanceList::updateProposalList);
 }
 
-GovernanceList::~GovernanceList()
+ProposalList::~ProposalList()
 {
-    m_timer->stop();
-    m_thread->quit();
-    m_thread->wait();
     delete ui;
 }
 
-void GovernanceList::changeEvent(QEvent* event)
+void ProposalList::changeEvent(QEvent* event)
 {
     QWidget::changeEvent(event);
     if (event->type() == QEvent::StyleChange) {
         QTimer::singleShot(0, proposalModel, &ProposalModel::refreshIcons);
-        QTimer::singleShot(0, this, &GovernanceList::updateEmptyPagePalette);
+        QTimer::singleShot(0, this, &ProposalList::updateEmptyPagePalette);
     }
 }
 
-void GovernanceList::updateEmptyPagePalette()
+void ProposalList::updateEmptyPagePalette()
 {
     QPalette emptyPalette = ui->emptyPage->palette();
     emptyPalette.setColor(QPalette::Window, ui->govTableView->palette().color(QPalette::Base));
     ui->emptyPage->setPalette(emptyPalette);
 }
 
-void GovernanceList::setClientModel(ClientModel* model)
+void ProposalList::setClientModel(ClientModel* model)
 {
     this->clientModel = model;
     if (!clientModel) {
-        m_timer->stop();
         return;
     }
-    connect(clientModel, &ClientModel::additionalDataSyncProgressChanged, this, &GovernanceList::updateProposalButtons);
-    connect(clientModel, &ClientModel::governanceChanged, this, [this] { handleProposalListChanged(/*force=*/false); });
-    connect(clientModel, &ClientModel::numBlocksChanged, this, [this] { handleProposalListChanged(/*force=*/false); });
-    connect(clientModel->getOptionsModel(), &OptionsModel::displayUnitChanged, this, &GovernanceList::updateDisplayUnit);
+    m_feed = clientModel->feedProposal();
+    if (m_feed) {
+        connect(m_feed, &ProposalFeed::dataReady, this, &ProposalList::updateProposalList);
+        updateProposalList();
+    }
+    connect(clientModel, &ClientModel::additionalDataSyncProgressChanged, this, &ProposalList::updateProposalButtons);
+    connect(clientModel->getOptionsModel(), &OptionsModel::displayUnitChanged, this, &ProposalList::updateDisplayUnit);
     if (walletModel && ui->proposalSourceCombo->findData(ToUnderlying(ProposalSource::Local)) == -1) {
         ui->proposalSourceCombo->addItem(tr("My Proposals"), ToUnderlying(ProposalSource::Local));
     }
-    m_timer->start(0);
 }
 
-std::vector<Governance::Object> GovernanceList::getWalletProposals(std::optional<bool> pending) const
+std::vector<Governance::Object> ProposalList::getWalletProposals(std::optional<bool> pending) const
 {
     if (!clientModel || !walletModel) {
         return {};
@@ -190,21 +173,19 @@ std::vector<Governance::Object> GovernanceList::getWalletProposals(std::optional
     return result;
 }
 
-void GovernanceList::setWalletModel(WalletModel* model)
+void ProposalList::setWalletModel(WalletModel* model)
 {
     this->walletModel = model;
     if (!walletModel || !clientModel) {
-        m_timer->stop();
         return;
     }
-    connect(walletModel, &WalletModel::balanceChanged, this, &GovernanceList::updateProposalButtons);
+    connect(walletModel, &WalletModel::balanceChanged, this, &ProposalList::updateProposalButtons);
     if (clientModel && ui->proposalSourceCombo->findData(ToUnderlying(ProposalSource::Local)) == -1) {
         ui->proposalSourceCombo->addItem(tr("My Proposals"), ToUnderlying(ProposalSource::Local));
     }
-    m_timer->start(0);
 }
 
-void GovernanceList::updateDisplayUnit()
+void ProposalList::updateDisplayUnit()
 {
     if (this->clientModel) {
         proposalModel->setDisplayUnit(this->clientModel->getOptionsModel()->getDisplayUnit());
@@ -212,24 +193,7 @@ void GovernanceList::updateDisplayUnit()
     }
 }
 
-void GovernanceList::handleProposalListChanged(bool force)
-{
-    if (!clientModel) {
-        return;
-    }
-    if (force) {
-        updateProposalList();
-    } else if (!m_timer->isActive()) {
-        int delay{GOVERNANCELIST_UPDATE_SECONDS * 1000};
-        if (!clientModel->masternodeSync().isBlockchainSynced()) {
-            // Currently syncing, reduce refreshes
-            delay *= 6;
-        }
-        m_timer->start(delay);
-    }
-}
-
-int GovernanceList::queryCollateralDepth(const uint256& collateralHash) const
+int ProposalList::queryCollateralDepth(const uint256& collateralHash) const
 {
     if (!walletModel) return 0;
     interfaces::WalletTxStatus tx_status;
@@ -241,104 +205,78 @@ int GovernanceList::queryCollateralDepth(const uint256& collateralHash) const
     return 0;
 }
 
-void GovernanceList::updateProposalList()
+void ProposalList::updateProposalList()
 {
-    if (!clientModel || clientModel->node().shutdownRequested()) {
+    if (!clientModel || !m_feed) {
         return;
     }
 
-    if (m_in_progress.exchange(true)) {
-        // Already applying, re-arm for next attempt
-        handleProposalListChanged(/*force=*/false);
+    auto feed = m_feed->data();
+    if (!feed) {
         return;
     }
 
-    QMetaObject::invokeMethod(m_worker, [this] {
-        auto result = std::make_shared<CalcProposalList>(calcProposalList());
-        m_in_progress.store(false);
-        QTimer::singleShot(0, this, [this, result] {
-            setProposalList(std::move(*result));
-        });
-    });
-}
+    // Assume that wallet-specific knowledge is stale
+    votableMasternodes.clear();
 
-GovernanceList::CalcProposalList GovernanceList::calcProposalList() const
-{
-    CalcProposalList ret;
-    if (!clientModel || clientModel->node().shutdownRequested()) {
-        return ret;
-    }
+    ProposalData ret;
+    ret.m_abs_vote_req = feed->m_abs_vote_req;
+    ret.m_gov_info = feed->m_gov_info;
+    ret.m_fundable_hashes = feed->m_fundable_hashes;
+    ret.m_proposals = feed->m_proposals;
 
-    const auto [dmn, pindex] = clientModel->getMasternodeList();
-    if (!dmn || !pindex) {
-        return ret;
+    // If we don't have a wallet, we can't fetch based on proposal source
+    if (!walletModel) {
+        setProposalList(std::move(ret));
+        return;
     }
 
-    // A proposal is considered passing if (YES votes - NO votes) >= (Total Weight of Masternodes / 10),
-    // count total valid (ENABLED) masternodes to determine passing threshold.
-    // Need to query number of masternodes here with access to clientModel.
-    const int nWeightedMnCount = dmn->getValidWeightedMNsCount();
-    ret.m_abs_vote_req = std::max(Params().GetConsensus().nGovernanceMinQuorum, nWeightedMnCount / 10);
-    ret.m_gov_info = clientModel->node().gov().getGovernanceInfo();
     if (m_proposal_source == ProposalSource::Active) {
-        std::vector<CGovernanceObject> govObjList;
-        clientModel->getAllGovernanceObjects(govObjList);
-        for (const auto& govObj : govObjList) {
-            if (govObj.GetObjectType() != GovernanceObject::PROPOSAL) {
-                continue; // Skip triggers.
-            }
-            ret.m_proposals.emplace_back(std::make_unique<Proposal>(this->clientModel, govObj, ret.m_gov_info, ret.m_gov_info.requiredConfs,
-                                                                    /*is_broadcast=*/true));
-        }
         // Include unrelayed wallet proposals (0 confs, not yet broadcast)
         for (const auto& obj : getWalletProposals(/*pending=*/true)) {
             CGovernanceObject govObj(obj.hashParent, obj.revision, obj.time, obj.collateralHash, obj.GetDataAsHexString());
-            ret.m_proposals.emplace_back(std::make_unique<Proposal>(this->clientModel, govObj, ret.m_gov_info, queryCollateralDepth(obj.collateralHash),
-                                                                    /*is_broadcast=*/false));
+            ret.m_proposals.emplace_back(std::make_shared<Proposal>(*clientModel, govObj, ret.m_gov_info, queryCollateralDepth(obj.collateralHash),
+                                                                     /*is_broadcast=*/false));
         }
     } else if (m_proposal_source == ProposalSource::Local) {
+        // Discard network proposals and only include wallet proposals
+        ret.m_proposals.clear();
         for (const auto& obj : getWalletProposals(/*pending=*/std::nullopt)) {
             CGovernanceObject govObj(obj.hashParent, obj.revision, obj.time, obj.collateralHash, obj.GetDataAsHexString());
-            ret.m_proposals.emplace_back(std::make_unique<Proposal>(this->clientModel, govObj, ret.m_gov_info, queryCollateralDepth(obj.collateralHash),
-                                                                    /*is_broadcast=*/clientModel->node().gov().existsObj(obj.GetHash())));
+            ret.m_proposals.emplace_back(std::make_shared<Proposal>(*clientModel, govObj, ret.m_gov_info, queryCollateralDepth(obj.collateralHash),
+                                                                     /*is_broadcast=*/clientModel->node().gov().existsObj(obj.GetHash())));
         }
     }
 
-    auto fundable{clientModel->node().gov().getFundableProposalHashes()};
-    ret.m_fundable_hashes = std::move(fundable.hashes);
-
-    // Discover voting capability if we now have both client and wallet models
-    if (walletModel) {
+    const auto [dmn, pindex] = clientModel->getMasternodeList();
+    if (dmn && pindex) {
         dmn->forEachMN(/*only_valid=*/true, [&](const auto& dmn) {
-            // Check if wallet owns the voting key using the same logic as RPC
             const auto script = GetScriptForDestination(PKHash(dmn.getKeyIdVoting()));
             if (walletModel->wallet().isSpendable(script)) {
-                ret.m_votable_masternodes[dmn.getProTxHash()] = dmn.getKeyIdVoting();
+                votableMasternodes[dmn.getProTxHash()] = dmn.getKeyIdVoting();
             }
         });
     }
-
-    return ret;
+    setProposalList(std::move(ret));
 }
 
-void GovernanceList::setProposalList(CalcProposalList&& data)
+void ProposalList::setProposalList(ProposalData&& data)
 {
     proposalModel->setVotingParams(data.m_abs_vote_req);
     proposalModel->reconcile(std::move(data.m_proposals), std::move(data.m_fundable_hashes));
     m_gov_info = std::move(data.m_gov_info);
-    votableMasternodes = std::move(data.m_votable_masternodes);
     updateMasternodeCount();
     updateProposalButtons();
 }
 
-void GovernanceList::updateProposalCount()
+void ProposalList::updateProposalCount()
 {
     ui->countLabel->setText(QString::number(proposalModelProxy->rowCount()));
     refreshColumnWidths();
     updateEmptyState();
 }
 
-void GovernanceList::updateEmptyState()
+void ProposalList::updateEmptyState()
 {
     const bool hasProposals = proposalModelProxy->rowCount() > 0;
     if (hasProposals) {
@@ -356,7 +294,7 @@ void GovernanceList::updateEmptyState()
     }
 }
 
-void GovernanceList::showCreateProposalDialog()
+void ProposalList::showCreateProposalDialog()
 {
     if (!this->clientModel || !this->walletModel) {
         QMessageBox::warning(this, tr("Unavailable"), tr("A synced node and an unlocked wallet are required."));
@@ -369,14 +307,14 @@ void GovernanceList::showCreateProposalDialog()
     proposalCreate->setWindowModality(Qt::NonModal);
     proposalCreate->setModal(false);
     proposalCreate->setWindowFlag(Qt::Window, true);
-    // Auto-open Resume dialog after successful creation and refresh the governance list
-    connect(proposalCreate, &QDialog::accepted, this, [this] { handleProposalListChanged(/*force=*/true); });
-    connect(proposalCreate, &QDialog::accepted, this, &GovernanceList::updateProposalButtons);
-    connect(proposalCreate, &QDialog::accepted, this, &GovernanceList::showResumeProposalDialog);
+    // Auto-open Resume dialog after successful creation and refresh the proposal list
+    connect(proposalCreate, &QDialog::accepted, m_feed, &ProposalFeed::requestForceRefresh);
+    connect(proposalCreate, &QDialog::accepted, this, &ProposalList::updateProposalButtons);
+    connect(proposalCreate, &QDialog::accepted, this, &ProposalList::showResumeProposalDialog);
     proposalCreate->show();
 }
 
-void GovernanceList::showResumeProposalDialog()
+void ProposalList::showResumeProposalDialog()
 {
     if (!clientModel || !walletModel) {
         QMessageBox::warning(this, tr("Resume proposal"), tr("A synced node and an unlocked wallet are required."));
@@ -384,8 +322,8 @@ void GovernanceList::showResumeProposalDialog()
     }
 
     const auto proposals = getWalletProposals(/*pending=*/true);
-    ProposalResume* dialog = new ProposalResume(clientModel->node(), clientModel, walletModel, proposals, this);
-    connect(dialog, &ProposalResume::proposalBroadcasted, this, [this] { handleProposalListChanged(/*force=*/true); });
+    ProposalResume* dialog = new ProposalResume(clientModel->node(), *clientModel, walletModel, proposals, this);
+    connect(dialog, &ProposalResume::proposalBroadcasted, m_feed, &ProposalFeed::requestForceRefresh);
     dialog->setAttribute(Qt::WA_DeleteOnClose, true);
     dialog->setWindowModality(Qt::NonModal);
     dialog->setModal(false);
@@ -393,7 +331,7 @@ void GovernanceList::showResumeProposalDialog()
     dialog->show();
 }
 
-void GovernanceList::showProposalContextMenu(const QPoint& pos)
+void ProposalList::showProposalContextMenu(const QPoint& pos)
 {
     const auto index = ui->govTableView->indexAt(pos);
 
@@ -407,23 +345,23 @@ void GovernanceList::showProposalContextMenu(const QPoint& pos)
     }
 
     proposalContextMenu->clear();
-    proposalContextMenu->addAction(tr("Copy Raw JSON"), this, &GovernanceList::copyProposalJson);
+    proposalContextMenu->addAction(tr("Copy Raw JSON"), this, &ProposalList::copyProposalJson);
     if (!proposal->url().isEmpty()) {
-        proposalContextMenu->addAction(tr("Open Proposal URL…"), this, &GovernanceList::openProposalUrl);
+        proposalContextMenu->addAction(tr("Open Proposal URL…"), this, &ProposalList::openProposalUrl);
     }
 
     // Add voting options if wallet is available and has voting capability
     if (walletModel && canVote()) {
         proposalContextMenu->addSeparator();
-        proposalContextMenu->addAction(tr("Vote Yes"), this, &GovernanceList::voteYes);
-        proposalContextMenu->addAction(tr("Vote No"), this, &GovernanceList::voteNo);
-        proposalContextMenu->addAction(tr("Vote Abstain"), this, &GovernanceList::voteAbstain);
+        proposalContextMenu->addAction(tr("Vote Yes"), this, &ProposalList::voteYes);
+        proposalContextMenu->addAction(tr("Vote No"), this, &ProposalList::voteNo);
+        proposalContextMenu->addAction(tr("Vote Abstain"), this, &ProposalList::voteAbstain);
     }
 
     proposalContextMenu->exec(QCursor::pos());
 }
 
-void GovernanceList::showAdditionalInfo(const QModelIndex& index)
+void ProposalList::showAdditionalInfo(const QModelIndex& index)
 {
     if (!index.isValid() || !clientModel) {
         return;
@@ -443,14 +381,14 @@ void GovernanceList::showAdditionalInfo(const QModelIndex& index)
     dialog->show();
 }
 
-void GovernanceList::updateMasternodeCount() const
+void ProposalList::updateMasternodeCount() const
 {
     if (ui && ui->mnCountLabel) {
         ui->mnCountLabel->setText(QString::number(votableMasternodes.size()));
     }
 }
 
-void GovernanceList::updateProposalButtons()
+void ProposalList::updateProposalButtons()
 {
     if (!clientModel || !clientModel->masternodeSync().isGovernanceSynced()) {
         const QString tooltip = tr("Cannot interact with governance before sync completes");
@@ -480,20 +418,20 @@ void GovernanceList::updateProposalButtons()
     }
 }
 
-void GovernanceList::setProposalSource(int index)
+void ProposalList::setProposalSource(int index)
 {
     m_proposal_source = static_cast<ProposalSource>(ui->proposalSourceCombo->itemData(index).toInt());
     ui->govTableView->setColumnHidden(ProposalModel::Column::VOTING_STATUS, m_proposal_source == ProposalSource::Local);
-    handleProposalListChanged(/*force=*/true);
+    updateProposalList();
 }
 
-void GovernanceList::voteYes() { voteForProposal(VOTE_OUTCOME_YES); }
+void ProposalList::voteYes() { voteForProposal(VOTE_OUTCOME_YES); }
 
-void GovernanceList::voteNo() { voteForProposal(VOTE_OUTCOME_NO); }
+void ProposalList::voteNo() { voteForProposal(VOTE_OUTCOME_NO); }
 
-void GovernanceList::voteAbstain() { voteForProposal(VOTE_OUTCOME_ABSTAIN); }
+void ProposalList::voteAbstain() { voteForProposal(VOTE_OUTCOME_ABSTAIN); }
 
-void GovernanceList::openProposalUrl()
+void ProposalList::openProposalUrl()
 {
     const auto selection = ui->govTableView->selectionModel()->selectedRows();
     if (selection.isEmpty()) {
@@ -526,7 +464,7 @@ void GovernanceList::openProposalUrl()
     }
 }
 
-void GovernanceList::copyProposalJson()
+void ProposalList::copyProposalJson()
 {
     const auto selection = ui->govTableView->selectionModel()->selectedRows();
     if (selection.isEmpty()) {
@@ -541,7 +479,7 @@ void GovernanceList::copyProposalJson()
     QApplication::clipboard()->setText(proposal->toJson());
 }
 
-void GovernanceList::voteForProposal(vote_outcome_enum_t outcome)
+void ProposalList::voteForProposal(vote_outcome_enum_t outcome)
 {
     if (!walletModel) {
         QMessageBox::warning(this, tr("Voting Failed"), tr("No wallet available."));
@@ -580,7 +518,7 @@ void GovernanceList::voteForProposal(vote_outcome_enum_t outcome)
 
     // Get masternode list once before the loop
     auto [mnList, pindex] = clientModel->getMasternodeList();
-    if (!pindex) {
+    if (!mnList || !pindex) {
         QMessageBox::warning(this, tr("Voting Failed"), tr("Unable to get masternode list. Please try again later."));
         return;
     }
@@ -635,22 +573,22 @@ void GovernanceList::voteForProposal(vote_outcome_enum_t outcome)
     QMessageBox::information(this, tr("Voting Results"), message);
 
     // Update proposal list to show new vote counts
-    handleProposalListChanged(/*force=*/true);
+    if (m_feed) m_feed->requestForceRefresh();
 }
 
-void GovernanceList::showEvent(QShowEvent* event)
+void ProposalList::showEvent(QShowEvent* event)
 {
     QWidget::showEvent(event);
     refreshColumnWidths();
 }
 
-void GovernanceList::resizeEvent(QResizeEvent* event)
+void ProposalList::resizeEvent(QResizeEvent* event)
 {
     QWidget::resizeEvent(event);
     refreshColumnWidths();
 }
 
-void GovernanceList::refreshColumnWidths()
+void ProposalList::refreshColumnWidths()
 {
     // Bail out if resize in progress or viewport is too small
     const int tableWidth = ui->govTableView->viewport()->width();
diff --git a/src/qt/governancelist.h b/src/qt/proposallist.h
similarity index 71%
rename from src/qt/governancelist.h
rename to src/qt/proposallist.h
index ae1eb0d6d878..cc2eca8ef751 100644
--- a/src/qt/governancelist.h
+++ b/src/qt/proposallist.h
@@ -2,8 +2,8 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#ifndef BITCOIN_QT_GOVERNANCELIST_H
-#define BITCOIN_QT_GOVERNANCELIST_H
+#ifndef BITCOIN_QT_PROPOSALLIST_H
+#define BITCOIN_QT_PROPOSALLIST_H
 
 #include <interfaces/node.h>
 #include <primitives/transaction.h>
@@ -14,28 +14,25 @@
 
 #include <QMenu>
 #include <QSortFilterProxyModel>
-#include <QTimer>
-#include <QThread>
 #include <QWidget>
 
-#include <atomic>
 #include <map>
 #include <optional>
 #include <vector>
 
-inline constexpr int GOVERNANCELIST_UPDATE_SECONDS = 10;
-
+class CDeterministicMNList;
 class ClientModel;
+class ProposalCreate;
+class ProposalFeed;
 class ProposalModel;
 class WalletModel;
-class ProposalCreate;
-class CDeterministicMNList;
 enum vote_outcome_enum_t : int;
+struct ProposalData;
 namespace Governance {
 class Object;
 } // namespace Governance
 namespace Ui {
-class GovernanceList;
+class ProposalList;
 } // namespace Ui
 
 enum class ProposalSource : uint8_t {
@@ -43,49 +40,36 @@ enum class ProposalSource : uint8_t {
     Local
 };
 
-/** Governance Manager page widget */
-class GovernanceList : public QWidget
+/** Proposal list widget */
+class ProposalList : public QWidget
 {
     Q_OBJECT
 
-    Ui::GovernanceList* ui;
+    Ui::ProposalList* ui;
 
 public:
-    explicit GovernanceList(QWidget* parent = nullptr);
-    ~GovernanceList() override;
+    explicit ProposalList(QWidget* parent = nullptr);
+    ~ProposalList() override;
     void setClientModel(ClientModel* clientModel);
     void setWalletModel(WalletModel* walletModel);
 
 private:
-    struct CalcProposalList {
-        int m_abs_vote_req{0};
-        interfaces::GOV::GovernanceInfo m_gov_info;
-        ProposalList m_proposals;
-        Uint256HashMap<CKeyID> m_votable_masternodes;
-        Uint256HashSet m_fundable_hashes;
-    };
-
     ClientModel* clientModel{nullptr};
     interfaces::GOV::GovernanceInfo m_gov_info;
+    ProposalFeed* m_feed{nullptr};
     ProposalModel* proposalModel{nullptr};
     ProposalSource m_proposal_source{ProposalSource::Active};
     QMenu* proposalContextMenu{nullptr};
-    QObject* m_worker{nullptr};
     QSortFilterProxyModel* proposalModelProxy{nullptr};
-    QThread* m_thread{nullptr};
-    QTimer* m_timer{nullptr};
     std::atomic<bool> m_col_refresh{false};
-    std::atomic<bool> m_in_progress{false};
     Uint256HashMap<CKeyID> votableMasternodes;
     WalletModel* walletModel{nullptr};
 
     bool canVote() const { return !votableMasternodes.empty(); }
-    CalcProposalList calcProposalList() const;
     int queryCollateralDepth(const uint256& collateralHash) const;
     std::vector<Governance::Object> getWalletProposals(std::optional<bool> pending) const;
-    void handleProposalListChanged(bool force);
     void refreshColumnWidths();
-    void setProposalList(CalcProposalList&& data);
+    void setProposalList(ProposalData&& data);
     void updateEmptyPagePalette();
     void updateEmptyState();
     void updateProposalButtons();
@@ -97,17 +81,17 @@ class GovernanceList : public QWidget
     void resizeEvent(QResizeEvent* event) override;
 
 private Q_SLOTS:
-    void updateDisplayUnit();
-    void updateProposalList();
-    void updateProposalCount();
-    void updateMasternodeCount() const;
+    void copyProposalJson();
+    void openProposalUrl();
     void setProposalSource(int index);
-    void showProposalContextMenu(const QPoint& pos);
     void showAdditionalInfo(const QModelIndex& index);
     void showCreateProposalDialog();
+    void showProposalContextMenu(const QPoint& pos);
     void showResumeProposalDialog();
-    void openProposalUrl();
-    void copyProposalJson();
+    void updateDisplayUnit();
+    void updateMasternodeCount() const;
+    void updateProposalCount();
+    void updateProposalList();
 
     // Voting slots
     void voteYes();
@@ -115,4 +99,4 @@ private Q_SLOTS:
     void voteAbstain();
 };
 
-#endif // BITCOIN_QT_GOVERNANCELIST_H
+#endif // BITCOIN_QT_PROPOSALLIST_H
diff --git a/src/qt/proposalmodel.cpp b/src/qt/proposalmodel.cpp
index 0257bf2846f7..3d7d057fcb95 100644
--- a/src/qt/proposalmodel.cpp
+++ b/src/qt/proposalmodel.cpp
@@ -20,12 +20,12 @@
 #include <algorithm>
 #include <cmath>
 
-Proposal::Proposal(ClientModel* _clientModel, const CGovernanceObject& _govObj,
+Proposal::Proposal(ClientModel& client_model, const CGovernanceObject& _govObj,
                    const interfaces::GOV::GovernanceInfo& govInfo, int collateral_confs,
                    bool is_broadcast) :
-    clientModel{_clientModel},
+    m_client_model{client_model},
     m_is_broadcast{is_broadcast},
-    m_block_height{_clientModel ? _clientModel->getNumBlocks() : 0},
+    m_block_height{client_model.getNumBlocks()},
     m_collateral_confs{collateral_confs},
     m_gov_info{govInfo},
     govObj{_govObj},
@@ -40,10 +40,8 @@ Proposal::Proposal(ClientModel* _clientModel, const CGovernanceObject& _govObj,
         return;
     }
 
-    if (clientModel) {
-        m_funded_height = clientModel->node().gov().getProposalFundedHeight(govObj.GetHash());
-        m_votes = clientModel->node().gov().getObjVotes(govObj, VOTE_SIGNAL_FUNDING);
-    }
+    m_funded_height = m_client_model.node().gov().getProposalFundedHeight(govObj.GetHash());
+    m_votes = m_client_model.node().gov().getObjVotes(govObj, VOTE_SIGNAL_FUNDING);
 
     if (const UniValue& titleValue = prop_data.find_value("name"); titleValue.isStr()) {
         m_title = QString::fromStdString(titleValue.get_str());
@@ -153,11 +151,8 @@ ProposalStatus Proposal::status(bool is_fundable) const
 
 bool Proposal::isActive() const
 {
-    if (!clientModel) {
-        return false;
-    }
-    std::string strError;
-    return clientModel->node().gov().getObjLocalValidity(govObj, strError, false);
+    std::string error;
+    return m_client_model.node().gov().getObjLocalValidity(govObj, error, false);
 }
 
 ///
@@ -364,7 +359,7 @@ QVariant ProposalModel::headerData(int section, Qt::Orientation orientation, int
     }
 }
 
-void ProposalModel::append(std::unique_ptr<Proposal>&& proposal)
+void ProposalModel::append(std::shared_ptr<Proposal>&& proposal)
 {
     beginInsertRows({}, rowCount(), rowCount());
     m_data.push_back(std::move(proposal));
@@ -381,7 +376,7 @@ void ProposalModel::remove(int row)
     endRemoveRows();
 }
 
-void ProposalModel::reconcile(ProposalList&& proposals, std::unordered_set<uint256, StaticSaltedHasher>&& fundable_hashes)
+void ProposalModel::reconcile(Proposals&& proposals, Uint256HashSet&& fundable_hashes)
 {
     m_fundable_hashes = std::move(fundable_hashes);
 
diff --git a/src/qt/proposalmodel.h b/src/qt/proposalmodel.h
index d91d419f90c5..83d927904160 100644
--- a/src/qt/proposalmodel.h
+++ b/src/qt/proposalmodel.h
@@ -39,7 +39,7 @@ enum class ProposalStatus : uint8_t {
 class Proposal
 {
 private:
-    ClientModel* clientModel;
+    ClientModel& m_client_model;
     bool m_is_broadcast{true};
     int m_block_height{0};
     int m_collateral_confs{0};
@@ -61,7 +61,7 @@ class Proposal
     uint256 m_objHash{};
 
 public:
-    explicit Proposal(ClientModel* _clientModel, const CGovernanceObject& _govObj,
+    explicit Proposal(ClientModel& client_model, const CGovernanceObject& _govObj,
                       const interfaces::GOV::GovernanceInfo& govInfo, int collateral_confs,
                       bool is_broadcast);
 
@@ -92,7 +92,7 @@ class Proposal
     std::optional<int> getFundedHeight() const { return m_funded_height; }
 };
 
-using ProposalList = std::vector<std::unique_ptr<Proposal>>;
+using Proposals = std::vector<std::shared_ptr<Proposal>>;
 
 class ProposalModel : public QAbstractTableModel
 {
@@ -101,7 +101,7 @@ class ProposalModel : public QAbstractTableModel
 private:
     BitcoinUnit m_display_unit{BitcoinUnit::DASH};
     int nAbsVoteReq{0};
-    ProposalList m_data;
+    Proposals m_data;
     QIcon m_icon_failing;
     QIcon m_icon_lapsed;
     QIcon m_icon_passing;
@@ -130,9 +130,9 @@ class ProposalModel : public QAbstractTableModel
     QVariant data(const QModelIndex& index, int role) const override;
     QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
 
-    void append(std::unique_ptr<Proposal>&& proposal);
+    void append(std::shared_ptr<Proposal>&& proposal);
     void remove(int row);
-    void reconcile(ProposalList&& proposals, Uint256HashSet&& fundable_hashes);
+    void reconcile(Proposals&& proposals, Uint256HashSet&& fundable_hashes);
     void refreshIcons();
     void setDisplayUnit(const BitcoinUnit& display_unit);
     void setVotingParams(int nAbsVoteReq);
diff --git a/src/qt/proposalresume.cpp b/src/qt/proposalresume.cpp
index e68870d16674..6b1fcd641563 100644
--- a/src/qt/proposalresume.cpp
+++ b/src/qt/proposalresume.cpp
@@ -33,7 +33,7 @@
 
 #include <algorithm>
 
-ProposalResume::ProposalResume(interfaces::Node& node, ClientModel* client_model, WalletModel* wallet_model,
+ProposalResume::ProposalResume(interfaces::Node& node, ClientModel& client_model, WalletModel* wallet_model,
                                const std::vector<Governance::Object>& proposals, QWidget* parent) :
     QDialog{parent},
     m_ui{new Ui::ProposalResume},
@@ -117,8 +117,8 @@ QString ProposalResume::formatProposalHtml(const Governance::Object& obj, int co
     const CGovernanceObject gov_obj(obj.hashParent, obj.revision, obj.time, obj.collateralHash, obj.GetDataAsHexString());
     const Proposal proposal(m_client_model, gov_obj, m_node.gov().getGovernanceInfo(), confirmations, /*is_broadcast=*/false);
     const BitcoinUnit unit = [this]() {
-        if (m_client_model && m_client_model->getOptionsModel()) {
-            return m_client_model->getOptionsModel()->getDisplayUnit();
+        if (m_client_model.getOptionsModel()) {
+            return m_client_model.getOptionsModel()->getDisplayUnit();
         }
         return BitcoinUnit::DASH;
     }();
diff --git a/src/qt/proposalresume.h b/src/qt/proposalresume.h
index 789e2666e147..64c2e86e751e 100644
--- a/src/qt/proposalresume.h
+++ b/src/qt/proposalresume.h
@@ -46,7 +46,7 @@ class ProposalResume : public QDialog
     Ui::ProposalResume* m_ui;
 
 public:
-    explicit ProposalResume(interfaces::Node& node, ClientModel* client_model, WalletModel* wallet_model,
+    explicit ProposalResume(interfaces::Node& node, ClientModel& client_model, WalletModel* wallet_model,
                             const std::vector<Governance::Object>& proposals, QWidget* parent = nullptr);
     ~ProposalResume();
 
@@ -64,7 +64,7 @@ private Q_SLOTS:
 
 private:
     interfaces::Node& m_node;
-    ClientModel* m_client_model;
+    ClientModel& m_client_model;
     WalletModel* m_wallet_model;
 
 private:
diff --git a/src/qt/res/css/dark.css b/src/qt/res/css/dark.css
index 6e23b1f2c727..4a32f5fbebee 100644
--- a/src/qt/res/css/dark.css
+++ b/src/qt/res/css/dark.css
@@ -830,10 +830,10 @@ EditAddressDialog
 /***** No dark.css specific coloring here yet *****/
 
 /******************************************************
-GovernanceList
+ProposalList
 ******************************************************/
 
-GovernanceList QTableView {
+ProposalList QTableView {
     color: #c7c7c7;
 }
 
diff --git a/src/qt/res/css/light.css b/src/qt/res/css/light.css
index dfdac7687a16..50d11d130c8a 100644
--- a/src/qt/res/css/light.css
+++ b/src/qt/res/css/light.css
@@ -816,10 +816,10 @@ EditAddressDialog
 /***** No light.css specific coloring here yet *****/
 
 /******************************************************
-GovernanceList
+ProposalList
 ******************************************************/
 
-GovernanceList QTableView {
+ProposalList QTableView {
     color: #555;
 }
 
diff --git a/src/qt/walletframe.cpp b/src/qt/walletframe.cpp
index 417847a6fe68..fef3675e24ad 100644
--- a/src/qt/walletframe.cpp
+++ b/src/qt/walletframe.cpp
@@ -7,14 +7,15 @@
 #include <fs.h>
 #include <node/interface_ui.h>
 #include <psbt.h>
-#include <qt/governancelist.h>
+#include <util/system.h>
+
 #include <qt/guiutil.h>
 #include <qt/masternodelist.h>
 #include <qt/overviewpage.h>
+#include <qt/proposallist.h>
 #include <qt/psbtoperationsdialog.h>
 #include <qt/walletmodel.h>
 #include <qt/walletview.h>
-#include <util/system.h>
 
 #include <cassert>
 #include <fstream>
@@ -58,8 +59,8 @@ WalletFrame::WalletFrame(QWidget* parent)
     masternodeListPage = new MasternodeList();
     walletStack->addWidget(masternodeListPage);
 
-    governanceListPage = new GovernanceList();
-    walletStack->addWidget(governanceListPage);
+    proposalListPage = new ProposalList();
+    walletStack->addWidget(proposalListPage);
 }
 
 WalletFrame::~WalletFrame() = default;
@@ -69,7 +70,7 @@ void WalletFrame::setClientModel(ClientModel *_clientModel)
     this->clientModel = _clientModel;
 
     masternodeListPage->setClientModel(_clientModel);
-    governanceListPage->setClientModel(_clientModel);
+    proposalListPage->setClientModel(_clientModel);
 
     for (auto i = mapWalletViews.constBegin(); i != mapWalletViews.constEnd(); ++i) {
         i.value()->setClientModel(_clientModel);
@@ -165,7 +166,7 @@ void WalletFrame::gotoGovernancePage()
     QMap<WalletModel*, WalletView*>::const_iterator i;
 
     if (mapWalletViews.empty()) {
-        walletStack->setCurrentWidget(governanceListPage);
+        walletStack->setCurrentWidget(proposalListPage);
         return;
     }
 
diff --git a/src/qt/walletframe.h b/src/qt/walletframe.h
index f2820c7dd410..de559454e0df 100644
--- a/src/qt/walletframe.h
+++ b/src/qt/walletframe.h
@@ -14,7 +14,7 @@ class SendCoinsRecipient;
 class WalletModel;
 class WalletView;
 class MasternodeList;
-class GovernanceList;
+class ProposalList;
 
 QT_BEGIN_NAMESPACE
 class QStackedWidget;
@@ -60,7 +60,7 @@ class WalletFrame : public QFrame
     QMap<WalletModel*, WalletView*> mapWalletViews;
     QGroupBox* no_wallet_group;
     MasternodeList* masternodeListPage;
-    GovernanceList* governanceListPage;
+    ProposalList* proposalListPage;
 
     bool bOutOfSync;
 
diff --git a/src/qt/walletview.cpp b/src/qt/walletview.cpp
index 70647639a0b6..c5cebb0bf527 100644
--- a/src/qt/walletview.cpp
+++ b/src/qt/walletview.cpp
@@ -103,9 +103,9 @@ WalletView::WalletView(WalletModel* wallet_model, QWidget* parent)
     masternodeListPage->setWalletModel(walletModel);
     addWidget(masternodeListPage);
 
-    governanceListPage = new GovernanceList();
-    governanceListPage->setWalletModel(walletModel);
-    addWidget(governanceListPage);
+    proposalListPage = new ProposalList();
+    proposalListPage->setWalletModel(walletModel);
+    addWidget(proposalListPage);
 
     connect(overviewPage, &OverviewPage::transactionClicked, this, &WalletView::transactionClicked);
     // Clicking on a transaction on the overview pre-selects the transaction on the transaction history page
@@ -169,8 +169,8 @@ void WalletView::setClientModel(ClientModel *_clientModel)
     if (masternodeListPage != nullptr) {
         masternodeListPage->setClientModel(_clientModel);
     }
-    if (governanceListPage != nullptr) {
-        governanceListPage->setClientModel(_clientModel);
+    if (proposalListPage != nullptr) {
+        proposalListPage->setClientModel(_clientModel);
     }
     walletModel->setClientModel(_clientModel);
 }
@@ -207,7 +207,7 @@ void WalletView::processNewTransaction(const QModelIndex& parent, int start, int
 
 void WalletView::gotoGovernancePage()
 {
-    setCurrentWidget(governanceListPage);
+    setCurrentWidget(proposalListPage);
 }
 
 void WalletView::gotoOverviewPage()
diff --git a/src/qt/walletview.h b/src/qt/walletview.h
index 4a527fbfb9bc..14f806c0aa28 100644
--- a/src/qt/walletview.h
+++ b/src/qt/walletview.h
@@ -6,9 +6,10 @@
 #define BITCOIN_QT_WALLETVIEW_H
 
 #include <consensus/amount.h>
+
 #include <qt/bitcoinunits.h>
-#include <qt/governancelist.h>
 #include <qt/masternodelist.h>
+#include <qt/proposallist.h>
 
 #include <QStackedWidget>
 
@@ -68,7 +69,7 @@ class WalletView : public QStackedWidget
     AddressBookPage *usedSendingAddressesPage;
     AddressBookPage *usedReceivingAddressesPage;
     MasternodeList* masternodeListPage{nullptr};
-    GovernanceList* governanceListPage{nullptr};
+    ProposalList* proposalListPage{nullptr};
 
     TransactionView *transactionView;
 
diff --git a/test/lint/lint-circular-dependencies.py b/test/lint/lint-circular-dependencies.py
index e15d8a927bb5..db7472d9eaef 100755
--- a/test/lint/lint-circular-dependencies.py
+++ b/test/lint/lint-circular-dependencies.py
@@ -52,6 +52,7 @@
     "qt/appearancewidget -> qt/guiutil -> qt/appearancewidget",
     "qt/bitcoinaddressvalidator -> qt/guiutil -> qt/bitcoinaddressvalidator",
     "qt/bitcoingui -> qt/guiutil -> qt/bitcoingui",
+    "qt/clientfeeds -> qt/clientmodel -> qt/clientfeeds",
     "qt/guiutil -> qt/qvalidatedlineedit -> qt/guiutil",
     "wallet/coinjoin -> wallet/receive -> wallet/coinjoin",
 )
diff --git a/test/util/data/non-backported.txt b/test/util/data/non-backported.txt
index 31c094ae421e..79ba20f5ec2d 100644
--- a/test/util/data/non-backported.txt
+++ b/test/util/data/non-backported.txt
@@ -28,13 +28,14 @@ src/masternode/*.cpp
 src/masternode/*.h
 src/messagesigner.*
 src/netfulfilledman.*
+src/qt/clientfeeds.*
 src/qt/descriptiondialog.*
-src/qt/governancelist.*
 src/qt/guiutil_font.*
 src/qt/masternodelist.*
 src/qt/masternodemodel.*
 src/qt/mnemonicverificationdialog.*
 src/qt/proposalcreate.*
+src/qt/proposallist.*
 src/qt/proposalmodel.*
 src/qt/proposalresume.*
 src/rpc/coinjoin.cpp