diff --git a/src/interfaces/node.h b/src/interfaces/node.h
--- a/src/interfaces/node.h
+++ b/src/interfaces/node.h
@@ -19,6 +19,8 @@
 #include <tuple>
 #include <vector>
 
+class CCoinControl;
+class CFeeRate;
 struct CNodeStateStats;
 struct CNodeStats;
 class Config;
@@ -149,9 +151,19 @@
     //! Get network active.
     virtual bool getNetworkActive() = 0;
 
+    //! Get minimum fee.
+    virtual Amount getMinimumFee(unsigned int tx_bytes,
+                                 const CCoinControl &coin_control) = 0;
+
     //! Get max tx fee.
     virtual Amount getMaxTxFee() = 0;
 
+    //! Get dust relay fee.
+    virtual CFeeRate getDustRelayFee() = 0;
+
+    //! Get pay tx fee.
+    virtual CFeeRate getPayTxFee() = 0;
+
     //! Execute rpc command.
     virtual UniValue executeRpc(Config &config, const std::string &command,
                                 const UniValue &params,
diff --git a/src/interfaces/node.cpp b/src/interfaces/node.cpp
--- a/src/interfaces/node.cpp
+++ b/src/interfaces/node.cpp
@@ -16,6 +16,8 @@
 #include <net_processing.h>
 #include <netaddress.h>
 #include <netbase.h>
+#include <policy/fees.h>
+#include <policy/policy.h>
 #include <primitives/block.h>
 #include <rpc/server.h>
 #include <scheduler.h>
@@ -30,6 +32,7 @@
 #include <config/bitcoin-config.h>
 #endif
 #ifdef ENABLE_WALLET
+#include <wallet/fees.h>
 #include <wallet/wallet.h>
 #define CHECK_WALLET(x) x
 #else
@@ -208,7 +211,16 @@
         bool getNetworkActive() override {
             return g_connman && g_connman->GetNetworkActive();
         }
+        Amount getMinimumFee(unsigned int tx_bytes,
+                             const CCoinControl &coin_control) override {
+            Amount result;
+            CHECK_WALLET(result =
+                             GetMinimumFee(tx_bytes, g_mempool, coin_control));
+            return result;
+        }
         Amount getMaxTxFee() override { return ::maxTxFee; }
+        CFeeRate getDustRelayFee() override { return ::dustRelayFee; }
+        CFeeRate getPayTxFee() override { CHECK_WALLET(return ::payTxFee); }
         UniValue executeRpc(Config &config, const std::string &command,
                             const UniValue &params,
                             const std::string &uri) override {
diff --git a/src/interfaces/wallet.h b/src/interfaces/wallet.h
--- a/src/interfaces/wallet.h
+++ b/src/interfaces/wallet.h
@@ -6,6 +6,7 @@
 #define BITCOIN_INTERFACES_WALLET_H
 
 #include <amount.h>                    // For Amount
+#include <primitives/transaction.h>    // For CTxOut
 #include <script/ismine.h>             // For isminefilter, isminetype
 #include <script/standard.h>           // For CTxDestination
 #include <support/allocators/secure.h> // For SecureString
@@ -16,6 +17,7 @@
 #include <map>
 #include <memory>
 #include <string>
+#include <tuple>
 #include <utility>
 #include <vector>
 
@@ -35,6 +37,7 @@
 class Handler;
 class PendingWalletTx;
 struct WalletBalances;
+struct WalletTxOut;
 
 using WalletOrderForm = std::vector<std::pair<std::string, std::string>>;
 using WalletValueMap = std::map<std::string, std::string>;
@@ -144,6 +147,16 @@
     //! Get available balance.
     virtual Amount getAvailableBalance(const CCoinControl &coin_control) = 0;
 
+    //! Return AvailableCoins + LockedCoins grouped by wallet address.
+    //! (put change in one group with wallet address)
+    using CoinsList = std::map<CTxDestination,
+                               std::vector<std::tuple<COutPoint, WalletTxOut>>>;
+    virtual CoinsList listCoins() = 0;
+
+    //! Return wallet transaction output information.
+    virtual std::vector<WalletTxOut>
+    getCoins(const std::vector<COutPoint> &outputs) = 0;
+
     // Return whether HD enabled.
     virtual bool hdEnabled() = 0;
 
@@ -212,6 +225,14 @@
     }
 };
 
+//! Wallet transaction output.
+struct WalletTxOut {
+    CTxOut txout;
+    int64_t time;
+    int depth_in_main_chain = -1;
+    bool is_spent = false;
+};
+
 //! Return implementation of Wallet interface. This function will be undefined
 //! in builds where ENABLE_WALLET is false.
 std::unique_ptr<Wallet> MakeWallet(CWallet &wallet);
diff --git a/src/interfaces/wallet.cpp b/src/interfaces/wallet.cpp
--- a/src/interfaces/wallet.cpp
+++ b/src/interfaces/wallet.cpp
@@ -50,6 +50,17 @@
         CReserveKey m_key;
     };
 
+    //! Construct wallet TxOut struct.
+    WalletTxOut MakeWalletTxOut(CWallet &wallet, const CWalletTx &wtx, int n,
+                                int depth) {
+        WalletTxOut result;
+        result.txout = wtx.tx->vout[n];
+        result.time = wtx.GetTxTime();
+        result.depth_in_main_chain = depth;
+        result.is_spent = wallet.IsSpent(wtx.GetId(), n);
+        return result;
+    }
+
     class WalletImpl : public Wallet {
     public:
         WalletImpl(CWallet &wallet) : m_wallet(wallet) {}
@@ -189,6 +200,37 @@
         Amount getAvailableBalance(const CCoinControl &coin_control) override {
             return m_wallet.GetAvailableBalance(&coin_control);
         }
+        CoinsList listCoins() override {
+            LOCK2(::cs_main, m_wallet.cs_wallet);
+            CoinsList result;
+            for (const auto &entry : m_wallet.ListCoins()) {
+                auto &group = result[entry.first];
+                for (const auto &coin : entry.second) {
+                    group.emplace_back(COutPoint(coin.tx->GetId(), coin.i),
+                                       MakeWalletTxOut(m_wallet, *coin.tx,
+                                                       coin.i, coin.nDepth));
+                }
+            }
+            return result;
+        }
+        std::vector<WalletTxOut>
+        getCoins(const std::vector<COutPoint> &outputs) override {
+            LOCK2(::cs_main, m_wallet.cs_wallet);
+            std::vector<WalletTxOut> result;
+            result.reserve(outputs.size());
+            for (const auto &output : outputs) {
+                result.emplace_back();
+                auto it = m_wallet.mapWallet.find(output.GetTxId());
+                if (it != m_wallet.mapWallet.end()) {
+                    int depth = it->second.GetDepthInMainChain();
+                    if (depth >= 0) {
+                        result.back() = MakeWalletTxOut(m_wallet, it->second,
+                                                        output.GetN(), depth);
+                    }
+                }
+            }
+            return result;
+        }
         bool hdEnabled() override { return m_wallet.IsHDEnabled(); }
         std::unique_ptr<Handler>
         handleShowProgress(ShowProgressFn fn) override {
diff --git a/src/qt/coincontroldialog.cpp b/src/qt/coincontroldialog.cpp
--- a/src/qt/coincontroldialog.cpp
+++ b/src/qt/coincontroldialog.cpp
@@ -2,24 +2,23 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "coincontroldialog.h"
-#include "ui_coincontroldialog.h"
-
-#include "addresstablemodel.h"
-#include "bitcoinunits.h"
-#include "guiutil.h"
-#include "optionsmodel.h"
-#include "platformstyle.h"
-#include "txmempool.h"
-#include "walletmodel.h"
-
-#include "dstencode.h"
-#include "init.h"
-#include "policy/policy.h"
-#include "validation.h" // For mempool
-#include "wallet/coincontrol.h"
-#include "wallet/fees.h"
-#include "wallet/wallet.h"
+#include <qt/coincontroldialog.h>
+#include <qt/forms/ui_coincontroldialog.h>
+
+#include <dstencode.h>
+#include <interfaces/node.h>
+#include <policy/policy.h>
+#include <qt/addresstablemodel.h>
+#include <qt/bitcoinunits.h>
+#include <qt/guiutil.h>
+#include <qt/optionsmodel.h>
+#include <qt/platformstyle.h>
+#include <qt/walletmodel.h>
+#include <txmempool.h>
+#include <validation.h> // For mempool
+#include <wallet/coincontrol.h>
+#include <wallet/fees.h>
+#include <wallet/wallet.h>
 
 #include <QApplication>
 #include <QCheckBox>
@@ -470,7 +469,7 @@
             CTxOut txout(amount,
                          static_cast<CScript>(std::vector<uint8_t>(24, 0)));
             txDummy.vout.push_back(txout);
-            if (txout.IsDust(dustRelayFee)) {
+            if (txout.IsDust(model->node().getDustRelayFee())) {
                 fDust = true;
             }
         }
@@ -486,16 +485,18 @@
     int nQuantityUncompressed = 0;
 
     std::vector<COutPoint> vCoinControl;
-    std::vector<COutput> vOutputs;
     coinControl()->ListSelected(vCoinControl);
-    model->getOutputs(vCoinControl, vOutputs);
 
-    for (const COutput &out : vOutputs) {
+    size_t i = 0;
+    for (const auto &out : model->wallet().getCoins(vCoinControl)) {
+        if (out.depth_in_main_chain < 0) {
+            continue;
+        }
+
         // unselect already spent, very unlikely scenario, this could happen
         // when selected are spent elsewhere, like rpc or another computer
-        uint256 txhash = out.tx->GetId();
-        COutPoint outpt(txhash, out.i);
-        if (model->isSpent(outpt)) {
+        const COutPoint &outpt = vCoinControl[i++];
+        if (out.is_spent) {
             coinControl()->UnSelect(outpt);
             continue;
         }
@@ -504,11 +505,11 @@
         nQuantity++;
 
         // Amount
-        nAmount += out.tx->tx->vout[out.i].nValue;
+        nAmount += out.txout.nValue;
 
         // Bytes
         CTxDestination address;
-        if (ExtractDestination(out.tx->tx->vout[out.i].scriptPubKey, address)) {
+        if (ExtractDestination(out.txout.scriptPubKey, address)) {
             CPubKey pubkey;
             CKeyID *keyid = boost::get<CKeyID>(&address);
             if (keyid && model->wallet().getPubKey(*keyid, pubkey)) {
@@ -546,7 +547,7 @@
         }
 
         // Fee
-        nPayFee = GetMinimumFee(nBytes, g_mempool, *coinControl());
+        nPayFee = model->node().getMinimumFee(nBytes, *coinControl());
 
         if (nPayAmount > Amount::zero()) {
             nChange = nAmount - nPayAmount;
@@ -559,10 +560,11 @@
             if (nChange > Amount::zero() && nChange < MIN_CHANGE) {
                 CTxOut txout(nChange,
                              static_cast<CScript>(std::vector<uint8_t>(24, 0)));
-                if (txout.IsDust(dustRelayFee)) {
+                if (txout.IsDust(model->node().getDustRelayFee())) {
                     // dust-change will be raised until no dust
                     if (CoinControlDialog::fSubtractFeeFromAmount) {
-                        nChange = txout.GetDustThreshold(dustRelayFee);
+                        nChange = txout.GetDustThreshold(
+                            model->node().getDustRelayFee());
                     } else {
                         nPayFee += nChange;
                         nChange = Amount::zero();
@@ -689,14 +691,12 @@
 
     int nDisplayUnit = model->getOptionsModel()->getDisplayUnit();
 
-    std::map<QString, std::vector<COutput>> mapCoins;
-    model->listCoins(mapCoins);
-
-    for (const std::pair<QString, std::vector<COutput>> &coins : mapCoins) {
+    for (const auto &coins : model->wallet().listCoins()) {
         CCoinControlWidgetItem *itemWalletAddress =
             new CCoinControlWidgetItem();
         itemWalletAddress->setCheckState(COLUMN_CHECKBOX, Qt::Unchecked);
-        QString sWalletAddress = coins.first;
+        QString sWalletAddress =
+            QString::fromStdString(EncodeDestination(coins.first));
         QString sWalletLabel =
             model->getAddressTableModel()->labelForAddress(sWalletAddress);
         if (sWalletLabel.isEmpty()) {
@@ -719,8 +719,10 @@
 
         Amount nSum = Amount::zero();
         int nChildren = 0;
-        for (const COutput &out : coins.second) {
-            nSum += out.tx->tx->vout[out.i].nValue;
+        for (const auto &outpair : coins.second) {
+            const COutPoint &output = std::get<0>(outpair);
+            const interfaces::WalletTxOut &out = std::get<1>(outpair);
+            nSum += out.txout.nValue;
             nChildren++;
 
             CCoinControlWidgetItem *itemOutput;
@@ -735,8 +737,7 @@
             // address
             CTxDestination outputAddress;
             QString sAddress = "";
-            if (ExtractDestination(out.tx->tx->vout[out.i].scriptPubKey,
-                                   outputAddress)) {
+            if (ExtractDestination(out.txout.scriptPubKey, outputAddress)) {
                 sAddress =
                     QString::fromStdString(EncodeDestination(outputAddress));
 
@@ -766,38 +767,35 @@
             // amount
             itemOutput->setText(
                 COLUMN_AMOUNT,
-                BitcoinUnits::format(nDisplayUnit,
-                                     out.tx->tx->vout[out.i].nValue));
+                BitcoinUnits::format(nDisplayUnit, out.txout.nValue));
             // padding so that sorting works correctly
             itemOutput->setData(
                 COLUMN_AMOUNT, Qt::UserRole,
-                QVariant(qlonglong(out.tx->tx->vout[out.i].nValue / SATOSHI)));
+                QVariant(qlonglong(out.txout.nValue / SATOSHI)));
 
             // date
-            itemOutput->setText(COLUMN_DATE,
-                                GUIUtil::dateTimeStr(out.tx->GetTxTime()));
+            itemOutput->setText(COLUMN_DATE, GUIUtil::dateTimeStr(out.time));
             itemOutput->setData(COLUMN_DATE, Qt::UserRole,
-                                QVariant((qlonglong)out.tx->GetTxTime()));
+                                QVariant((qlonglong)out.time));
 
             // confirmations
             itemOutput->setText(COLUMN_CONFIRMATIONS,
-                                QString::number(out.nDepth));
+                                QString::number(out.depth_in_main_chain));
             itemOutput->setData(COLUMN_CONFIRMATIONS, Qt::UserRole,
-                                QVariant((qlonglong)out.nDepth));
+                                QVariant((qlonglong)out.depth_in_main_chain));
 
             // transaction id
-            const TxId txid = out.tx->GetId();
-            itemOutput->setText(COLUMN_TXHASH,
-                                QString::fromStdString(txid.GetHex()));
+            itemOutput->setText(COLUMN_TXHASH, QString::fromStdString(
+                                                   output.GetTxId().GetHex()));
 
             // vout index
-            itemOutput->setText(COLUMN_VOUT_INDEX, QString::number(out.i));
+            itemOutput->setText(COLUMN_VOUT_INDEX,
+                                QString::number(output.GetN()));
 
             // disable locked coins
-            if (model->wallet().isLockedCoin(COutPoint(txid, out.i))) {
-                COutPoint outpt(txid, out.i);
+            if (model->wallet().isLockedCoin(output)) {
                 // just to be sure
-                coinControl()->UnSelect(outpt);
+                coinControl()->UnSelect(output);
                 itemOutput->setDisabled(true);
                 itemOutput->setIcon(
                     COLUMN_CHECKBOX,
@@ -805,7 +803,7 @@
             }
 
             // set checkbox
-            if (coinControl()->IsSelected(COutPoint(txid, out.i))) {
+            if (coinControl()->IsSelected(output)) {
                 itemOutput->setCheckState(COLUMN_CHECKBOX, Qt::Checked);
             }
         }
diff --git a/src/qt/walletmodel.h b/src/qt/walletmodel.h
--- a/src/qt/walletmodel.h
+++ b/src/qt/walletmodel.h
@@ -203,11 +203,6 @@
 
     UnlockContext requestUnlock();
 
-    void getOutputs(const std::vector<COutPoint> &vOutpoints,
-                    std::vector<COutput> &vOutputs);
-    bool isSpent(const COutPoint &outpoint) const;
-    void listCoins(std::map<QString, std::vector<COutput>> &mapCoins) const;
-
     void loadReceiveRequests(std::vector<std::string> &vReceiveRequests);
     bool saveReceiveRequest(const std::string &sAddress, const int64_t nId,
                             const std::string &sRequest);
diff --git a/src/qt/walletmodel.cpp b/src/qt/walletmodel.cpp
--- a/src/qt/walletmodel.cpp
+++ b/src/qt/walletmodel.cpp
@@ -453,43 +453,6 @@
     rhs.relock = false;
 }
 
-// returns a list of COutputs from COutPoints
-void WalletModel::getOutputs(const std::vector<COutPoint> &vOutpoints,
-                             std::vector<COutput> &vOutputs) {
-    LOCK2(cs_main, cwallet->cs_wallet);
-    for (const COutPoint &outpoint : vOutpoints) {
-        auto it = cwallet->mapWallet.find(outpoint.GetTxId());
-        if (it == cwallet->mapWallet.end()) {
-            continue;
-        }
-        int nDepth = it->second.GetDepthInMainChain();
-        if (nDepth < 0) {
-            continue;
-        }
-        COutput out(&it->second, outpoint.GetN(), nDepth, true /* spendable */,
-                    true /* solvable */, true /* safe */);
-        vOutputs.push_back(out);
-    }
-}
-
-bool WalletModel::isSpent(const COutPoint &outpoint) const {
-    LOCK2(cs_main, cwallet->cs_wallet);
-    return cwallet->IsSpent(outpoint.GetTxId(), outpoint.GetN());
-}
-
-// AvailableCoins + LockedCoins grouped by wallet address (put change in one
-// group with wallet address)
-void WalletModel::listCoins(
-    std::map<QString, std::vector<COutput>> &mapCoins) const {
-    for (auto &group : cwallet->ListCoins()) {
-        auto &resultGroup =
-            mapCoins[QString::fromStdString(EncodeDestination(group.first))];
-        for (auto &coin : group.second) {
-            resultGroup.emplace_back(std::move(coin));
-        }
-    }
-}
-
 void WalletModel::loadReceiveRequests(
     std::vector<std::string> &vReceiveRequests) {
     // receive request