diff --git a/src/interfaces/node.h b/src/interfaces/node.h
--- a/src/interfaces/node.h
+++ b/src/interfaces/node.h
@@ -31,7 +31,6 @@
 class UniValue;
 
 namespace interfaces {
-
 class Handler;
 class Wallet;
 
@@ -154,13 +153,6 @@
     //! Get network active.
     virtual bool getNetworkActive() = 0;
 
-    //! Get required fee.
-    virtual Amount getRequiredFee(unsigned int tx_bytes) = 0;
-
-    //! Get minimum fee.
-    virtual Amount getMinimumFee(unsigned int tx_bytes,
-                                 const CCoinControl &coin_control) = 0;
-
     //! Get max tx fee.
     virtual Amount getMaxTxFee() = 0;
 
diff --git a/src/interfaces/node.cpp b/src/interfaces/node.cpp
--- a/src/interfaces/node.cpp
+++ b/src/interfaces/node.cpp
@@ -207,16 +207,6 @@
         bool getNetworkActive() override {
             return g_connman && g_connman->GetNetworkActive();
         }
-        Amount getRequiredFee(unsigned int tx_bytes) override {
-            CHECK_WALLET(return GetRequiredFee(tx_bytes));
-        }
-        Amount getMinimumFee(unsigned int tx_bytes,
-                             const CCoinControl &coin_control) override {
-            Amount result;
-            CHECK_WALLET(result =
-                             GetMinimumFee(tx_bytes, coin_control, g_mempool));
-            return result;
-        }
         Amount getMaxTxFee() override { return ::maxTxFee; }
         CFeeRate estimateSmartFee() override { return g_mempool.estimateFee(); }
         CFeeRate getDustRelayFee() override { return ::dustRelayFee; }
diff --git a/src/interfaces/wallet.h b/src/interfaces/wallet.h
--- a/src/interfaces/wallet.h
+++ b/src/interfaces/wallet.h
@@ -211,6 +211,13 @@
     virtual std::vector<WalletTxOut>
     getCoins(const std::vector<COutPoint> &outputs) = 0;
 
+    //! Get required fee.
+    virtual Amount getRequiredFee(unsigned int tx_bytes) = 0;
+
+    //! Get minimum fee.
+    virtual Amount getMinimumFee(unsigned int tx_bytes,
+                                 const CCoinControl &coin_control) = 0;
+
     // Return whether HD enabled.
     virtual bool hdEnabled() = 0;
 
diff --git a/src/interfaces/wallet.cpp b/src/interfaces/wallet.cpp
--- a/src/interfaces/wallet.cpp
+++ b/src/interfaces/wallet.cpp
@@ -9,6 +9,7 @@
 #include <consensus/validation.h>
 #include <interfaces/handler.h>
 #include <net.h>
+#include <policy/fees.h>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <script/ismine.h>
@@ -18,6 +19,7 @@
 #include <timedata.h>
 #include <ui_interface.h>
 #include <validation.h>
+#include <wallet/fees.h>
 #include <wallet/finaltx.h>
 #include <wallet/wallet.h>
 
@@ -410,6 +412,13 @@
         handleWatchOnlyChanged(WatchOnlyChangedFn fn) override {
             return MakeHandler(m_wallet.NotifyWatchonlyChanged.connect(fn));
         }
+        Amount getRequiredFee(unsigned int tx_bytes) override {
+            return GetRequiredFee(m_wallet, tx_bytes);
+        }
+        Amount getMinimumFee(unsigned int tx_bytes,
+                             const CCoinControl &coin_control) override {
+            return GetMinimumFee(m_wallet, tx_bytes, coin_control, g_mempool);
+        }
 
         CWallet &m_wallet;
     };
diff --git a/src/qt/coincontroldialog.cpp b/src/qt/coincontroldialog.cpp
--- a/src/qt/coincontroldialog.cpp
+++ b/src/qt/coincontroldialog.cpp
@@ -544,7 +544,7 @@
         }
 
         // Fee
-        nPayFee = model->node().getMinimumFee(nBytes, *coinControl());
+        nPayFee = model->wallet().getMinimumFee(nBytes, *coinControl());
 
         if (nPayAmount > Amount::zero()) {
             nChange = nAmount - nPayAmount;
diff --git a/src/qt/sendcoinsdialog.cpp b/src/qt/sendcoinsdialog.cpp
--- a/src/qt/sendcoinsdialog.cpp
+++ b/src/qt/sendcoinsdialog.cpp
@@ -122,7 +122,7 @@
     }
     if (!settings.contains("nTransactionFee")) {
         settings.setValue("nTransactionFee",
-                          qint64(DEFAULT_TRANSACTION_FEE / SATOSHI));
+                          qint64(DEFAULT_PAY_TX_FEE / SATOSHI));
     }
     if (!settings.contains("fPayOnlyMinFee")) {
         settings.setValue("fPayOnlyMinFee", false);
@@ -198,7 +198,7 @@
         connect(ui->checkBoxMinimumFee, SIGNAL(stateChanged(int)), this,
                 SLOT(coinControlUpdateLabels()));
 
-        ui->customFee->setSingleStep(model->node().getRequiredFee(1000));
+        ui->customFee->setSingleStep(model->wallet().getRequiredFee(1000));
         updateFeeSectionControls();
         updateMinFeeLabel();
         updateSmartFeeLabel();
@@ -644,7 +644,7 @@
 
 void SendCoinsDialog::setMinimumFee() {
     ui->radioCustomPerKilobyte->setChecked(true);
-    ui->customFee->setValue(model->node().getRequiredFee(1000));
+    ui->customFee->setValue(model->wallet().getRequiredFee(1000));
 }
 
 void SendCoinsDialog::updateFeeSectionControls() {
@@ -682,7 +682,7 @@
             tr("Pay only the required fee of %1")
                 .arg(BitcoinUnits::formatWithUnit(
                          model->getOptionsModel()->getDisplayUnit(),
-                         model->node().getRequiredFee(1000)) +
+                         model->wallet().getRequiredFee(1000)) +
                      "/kB"));
     }
 }
@@ -704,8 +704,7 @@
     updateCoinControlState(coin_control);
     // Explicitly use only fee estimation rate for smart fee labels
     coin_control.m_feerate.reset();
-
-    CFeeRate feeRate(model->node().getMinimumFee(1000, coin_control));
+    CFeeRate feeRate(model->wallet().getMinimumFee(1000, coin_control));
 
     ui->labelSmartFee->setText(
         BitcoinUnits::formatWithUnit(model->getOptionsModel()->getDisplayUnit(),
diff --git a/src/wallet/coincontrol.h b/src/wallet/coincontrol.h
--- a/src/wallet/coincontrol.h
+++ b/src/wallet/coincontrol.h
@@ -22,7 +22,7 @@
     bool fAllowWatchOnly;
     //! Override automatic min/max checks on fee, m_feerate must be set if true
     bool fOverrideFeeRate;
-    //! Override the default payTxFee if set
+    //! Override the wallet's m_pay_tx_fee if set
     boost::optional<CFeeRate> m_feerate;
     //! Override the default confirmation target if set
     boost::optional<unsigned int> m_confirm_target;
diff --git a/src/wallet/fees.h b/src/wallet/fees.h
--- a/src/wallet/fees.h
+++ b/src/wallet/fees.h
@@ -12,31 +12,33 @@
 
 class CCoinControl;
 class CTxMemPool;
+class CWallet;
 
 /**
- * Return the minimum required fee taking into account the
- * floating relay fee and user set minimum transaction fee
+ * Return the minimum required absolute fee for this size
+ * based on the required fee rate
  */
-Amount GetRequiredFee(unsigned int nTxBytes);
+Amount GetRequiredFee(const CWallet &wallet, unsigned int nTxBytes);
 
 /**
  * Estimate the minimum fee considering user set parameters
  * and the required fee
  */
-Amount GetMinimumFee(unsigned int nTxBytes, const CCoinControl &coinControl,
-                     const CTxMemPool &pool);
+Amount GetMinimumFee(const CWallet &wallet, unsigned int nTxBytes,
+                     const CCoinControl &coin_control, const CTxMemPool &pool);
 
 /**
  * Return the minimum required feerate taking into account the
- * floating relay feerate and user set minimum transaction feerate
+ * minimum relay feerate and user set minimum transaction feerate
  */
-CFeeRate GetRequiredFeeRate();
+CFeeRate GetRequiredFeeRate(const CWallet &wallet);
 
 /**
  * Estimate the minimum fee rate considering user set parameters
  * and the required fee
  */
-CFeeRate GetMinimumFeeRate(const CCoinControl &coin_control,
+CFeeRate GetMinimumFeeRate(const CWallet &wallet,
+                           const CCoinControl &coin_control,
                            const CTxMemPool &pool);
 
 #endif // BITCOIN_WALLET_FEES_H
diff --git a/src/wallet/fees.cpp b/src/wallet/fees.cpp
--- a/src/wallet/fees.cpp
+++ b/src/wallet/fees.cpp
@@ -13,14 +13,14 @@
 #include <wallet/coincontrol.h>
 #include <wallet/wallet.h>
 
-Amount GetRequiredFee(unsigned int nTxBytes) {
-    return GetRequiredFeeRate().GetFeeCeiling(nTxBytes);
+Amount GetRequiredFee(const CWallet &wallet, unsigned int nTxBytes) {
+    return GetRequiredFeeRate(wallet).GetFeeCeiling(nTxBytes);
 }
 
-Amount GetMinimumFee(unsigned int nTxBytes, const CCoinControl &coin_control,
-                     const CTxMemPool &pool) {
+Amount GetMinimumFee(const CWallet &wallet, unsigned int nTxBytes,
+                     const CCoinControl &coin_control, const CTxMemPool &pool) {
     Amount nFeeNeeded =
-        GetMinimumFeeRate(coin_control, pool).GetFeeCeiling(nTxBytes);
+        GetMinimumFeeRate(wallet, coin_control, pool).GetFeeCeiling(nTxBytes);
 
     // But always obey the maximum.
     if (nFeeNeeded > maxTxFee) {
@@ -30,26 +30,27 @@
     return nFeeNeeded;
 }
 
-CFeeRate GetRequiredFeeRate() {
-    return std::max(CWallet::minTxFee, ::minRelayTxFee);
+CFeeRate GetRequiredFeeRate(const CWallet &wallet) {
+    return std::max(wallet.m_min_fee, ::minRelayTxFee);
 }
 
-CFeeRate GetMinimumFeeRate(const CCoinControl &coin_control,
+CFeeRate GetMinimumFeeRate(const CWallet &wallet,
+                           const CCoinControl &coin_control,
                            const CTxMemPool &pool) {
     CFeeRate neededFeeRate =
         (coin_control.fOverrideFeeRate && coin_control.m_feerate)
             ? *coin_control.m_feerate
-            : payTxFee;
+            : wallet.m_pay_tx_fee;
 
     if (neededFeeRate == CFeeRate()) {
         neededFeeRate = pool.estimateFee();
         // ... unless we don't have enough mempool data for estimatefee, then
-        // use fallbackFee.
+        // use fallback fee.
         if (neededFeeRate == CFeeRate()) {
-            neededFeeRate = CWallet::fallbackFee;
+            neededFeeRate = wallet.m_fallback_fee;
         }
     }
 
     // Prevent user from paying a fee below minRelayTxFee or minTxFee.
-    return std::max(neededFeeRate, GetRequiredFeeRate());
+    return std::max(neededFeeRate, GetRequiredFeeRate(wallet));
 }
diff --git a/src/wallet/init.cpp b/src/wallet/init.cpp
--- a/src/wallet/init.cpp
+++ b/src/wallet/init.cpp
@@ -82,7 +82,8 @@
         "-paytxfee=<amt>",
         strprintf(
             _("Fee (in %s/kB) to add to transactions you send (default: %s)"),
-            CURRENCY_UNIT, FormatMoney(payTxFee.GetFeePerK())),
+            CURRENCY_UNIT,
+            FormatMoney(CFeeRate{DEFAULT_PAY_TX_FEE}.GetFeePerK())),
         false, OptionsCategory::WALLET);
     gArgs.AddArg(
         "-rescan",
@@ -230,45 +231,6 @@
             _("The wallet will avoid paying less than the minimum relay fee."));
     }
 
-    if (gArgs.IsArgSet("-fallbackfee")) {
-        Amount nFeePerK = Amount::zero();
-        if (!ParseMoney(gArgs.GetArg("-fallbackfee", ""), nFeePerK)) {
-            return InitError(
-                strprintf(_("Invalid amount for -fallbackfee=<amount>: '%s'"),
-                          gArgs.GetArg("-fallbackfee", "")));
-        }
-
-        if (nFeePerK > HIGH_TX_FEE_PER_KB) {
-            InitWarning(AmountHighWarn("-fallbackfee") + " " +
-                        _("This is the transaction fee you may pay when fee "
-                          "estimates are not available."));
-        }
-
-        CWallet::fallbackFee = CFeeRate(nFeePerK);
-    }
-
-    if (gArgs.IsArgSet("-paytxfee")) {
-        Amount nFeePerK = Amount::zero();
-        if (!ParseMoney(gArgs.GetArg("-paytxfee", ""), nFeePerK)) {
-            return InitError(
-                AmountErrMsg("paytxfee", gArgs.GetArg("-paytxfee", "")));
-        }
-
-        if (nFeePerK > HIGH_TX_FEE_PER_KB) {
-            InitWarning(AmountHighWarn("-paytxfee") + " " +
-                        _("This is the transaction fee you will pay if you "
-                          "send a transaction."));
-        }
-
-        payTxFee = CFeeRate(nFeePerK, 1000);
-        if (payTxFee < minRelayTxFee) {
-            return InitError(strprintf(
-                _("Invalid amount for -paytxfee=<amount>: '%s' (must "
-                  "be at least %s)"),
-                gArgs.GetArg("-paytxfee", ""), minRelayTxFee.ToString()));
-        }
-    }
-
     if (gArgs.IsArgSet("-maxtxfee")) {
         Amount nMaxFee = Amount::zero();
         if (!ParseMoney(gArgs.GetArg("-maxtxfee", ""), nMaxFee)) {
@@ -291,26 +253,6 @@
         }
     }
 
-    if (gArgs.IsArgSet("-mintxfee")) {
-        Amount n = Amount::zero();
-        auto parsed = ParseMoney(gArgs.GetArg("-mintxfee", ""), n);
-        if (!parsed || n == Amount::zero()) {
-            return InitError(
-                AmountErrMsg("mintxfee", gArgs.GetArg("-mintxfee", "")));
-        }
-
-        if (n > HIGH_TX_FEE_PER_KB) {
-            InitWarning(AmountHighWarn("-mintxfee") + " " +
-                        _("This is the minimum transaction fee you pay on "
-                          "every transaction."));
-        }
-
-        CWallet::minTxFee = CFeeRate(n);
-    }
-
-    bSpendZeroConfChange =
-        gArgs.GetBoolArg("-spendzeroconfchange", DEFAULT_SPEND_ZEROCONF_CHANGE);
-
     g_address_type = OutputType::DEFAULT;
     g_change_type = OutputType::DEFAULT;
 
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -3081,8 +3081,8 @@
         request.params.size() > 1) {
         throw std::runtime_error(
             "settxfee amount\n"
-            "\nSet the transaction fee per kB. Overwrites the paytxfee "
-            "parameter.\n"
+            "\nSet the transaction fee per kB for this wallet. Overrides the "
+            "global -paytxfee command line parameter.\n"
             "\nArguments:\n"
             "1. amount         (numeric or string, required) The transaction "
             "fee in " +
@@ -3097,10 +3097,9 @@
 
     LOCK2(cs_main, pwallet->cs_wallet);
 
-    // Amount
     Amount nAmount = AmountFromValue(request.params[0]);
 
-    payTxFee = CFeeRate(nAmount, 1000);
+    pwallet->m_pay_tx_fee = CFeeRate(nAmount, 1000);
     return true;
 }
 
@@ -3185,7 +3184,7 @@
     if (pwallet->IsCrypted()) {
         obj.pushKV("unlocked_until", pwallet->nRelockTime);
     }
-    obj.pushKV("paytxfee", ValueFromAmount(payTxFee.GetFeePerK()));
+    obj.pushKV("paytxfee", ValueFromAmount(pwallet->m_pay_tx_fee.GetFeePerK()));
     if (!masterKeyID.IsNull()) {
         obj.pushKV("hdmasterkeyid", masterKeyID.GetHex());
     }
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -34,15 +34,9 @@
 typedef CWallet *CWalletRef;
 extern std::vector<CWalletRef> vpwallets;
 
-/**
- * Settings
- */
-extern CFeeRate payTxFee;
-extern bool bSpendZeroConfChange;
-
 static const unsigned int DEFAULT_KEYPOOL_SIZE = 1000;
 //! -paytxfee default
-static const Amount DEFAULT_TRANSACTION_FEE = Amount::zero();
+constexpr Amount DEFAULT_PAY_TX_FEE = Amount::zero();
 //! -fallbackfee default
 static const Amount DEFAULT_FALLBACK_FEE(20000 * SATOSHI);
 //! -mintxfee default
@@ -1072,8 +1066,18 @@
                      const std::vector<CTxOut> &txouts) const;
     bool DummySignInput(CTxIn &tx_in, const CTxOut &txout) const;
 
-    static CFeeRate minTxFee;
-    static CFeeRate fallbackFee;
+    CFeeRate m_pay_tx_fee{DEFAULT_PAY_TX_FEE};
+    bool m_spend_zero_conf_change{DEFAULT_SPEND_ZEROCONF_CHANGE};
+    // will be defined via chainparams
+    bool m_allow_fallback_fee{true};
+    // Override with -mintxfee
+    CFeeRate m_min_fee{DEFAULT_TRANSACTION_MINFEE_PER_KB};
+    /**
+     * If fee estimation does not have enough data to provide estimates, use
+     * this fee instead. Has no effect if not using fee estimation Override with
+     * -fallbackfee
+     */
+    CFeeRate m_fallback_fee{DEFAULT_FALLBACK_FEE};
 
     bool NewKeyPool();
     size_t KeypoolCountExternalKeys();
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -42,29 +42,11 @@
 
 std::vector<CWalletRef> vpwallets;
 
-/** Transaction fee set by the user */
-CFeeRate payTxFee(DEFAULT_TRANSACTION_FEE);
-bool bSpendZeroConfChange = DEFAULT_SPEND_ZEROCONF_CHANGE;
-
 OutputType g_address_type = OutputType::NONE;
 OutputType g_change_type = OutputType::NONE;
 
 const uint32_t BIP32_HARDENED_KEY_LIMIT = 0x80000000;
 
-/**
- * Fees smaller than this (in satoshi) are considered zero fee (for transaction
- * creation)
- * Override with -mintxfee
- */
-CFeeRate CWallet::minTxFee = CFeeRate(DEFAULT_TRANSACTION_MINFEE_PER_KB);
-
-/**
- * If fee estimation does not have enough data to provide estimates, use this
- * fee instead. Has no effect if not using fee estimation.
- * Override with -fallbackfee
- */
-CFeeRate CWallet::fallbackFee = CFeeRate(DEFAULT_FALLBACK_FEE);
-
 const uint256 CMerkleTx::ABANDON_HASH(uint256S(
     "0000000000000000000000000000000000000000000000000000000000000001"));
 
@@ -2149,7 +2131,7 @@
     }
 
     // using wtx's cached debit
-    if (!bSpendZeroConfChange || !IsFromMe(ISMINE_ALL)) {
+    if (!pwallet->m_spend_zero_conf_change || !IsFromMe(ISMINE_ALL)) {
         return false;
     }
 
@@ -2625,7 +2607,7 @@
         // Get long term estimate
         CCoinControl temp;
         temp.m_confirm_target = 1008;
-        CFeeRate long_term_feerate = GetMinimumFeeRate(temp, g_mempool);
+        CFeeRate long_term_feerate = GetMinimumFeeRate(*this, temp, g_mempool);
 
         // Calculate cost of change
         Amount cost_of_change =
@@ -2763,30 +2745,30 @@
         SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs,
                            CoinEligibilityFilter(1, 1, 0), vCoins, setCoinsRet,
                            nValueRet, coin_selection_params, bnb_used) ||
-        (bSpendZeroConfChange &&
+        (m_spend_zero_conf_change &&
          SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs,
                             CoinEligibilityFilter(0, 1, 2), vCoins, setCoinsRet,
                             nValueRet, coin_selection_params, bnb_used)) ||
-        (bSpendZeroConfChange &&
+        (m_spend_zero_conf_change &&
          SelectCoinsMinConf(
              nTargetValue - nValueFromPresetInputs,
              CoinEligibilityFilter(0, 1, std::min<size_t>(4, max_ancestors / 3),
                                    std::min<size_t>(4, max_descendants / 3)),
              vCoins, setCoinsRet, nValueRet, coin_selection_params,
              bnb_used)) ||
-        (bSpendZeroConfChange &&
+        (m_spend_zero_conf_change &&
          SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs,
                             CoinEligibilityFilter(0, 1, max_ancestors / 2,
                                                   max_descendants / 2),
                             vCoins, setCoinsRet, nValueRet,
                             coin_selection_params, bnb_used)) ||
-        (bSpendZeroConfChange &&
+        (m_spend_zero_conf_change &&
          SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs,
                             CoinEligibilityFilter(0, 1, max_ancestors - 1,
                                                   max_descendants - 1),
                             vCoins, setCoinsRet, nValueRet,
                             coin_selection_params, bnb_used)) ||
-        (bSpendZeroConfChange && !fRejectLongChains &&
+        (m_spend_zero_conf_change && !fRejectLongChains &&
          SelectCoinsMinConf(
              nTargetValue - nValueFromPresetInputs,
              CoinEligibilityFilter(0, 1, std::numeric_limits<uint64_t>::max()),
@@ -3010,7 +2992,8 @@
             GetSerializeSize(change_prototype_txout, SER_DISK, 0);
 
         // Get the fee rate to use effective values in coin selection
-        CFeeRate nFeeRateNeeded = GetMinimumFeeRate(coinControl, g_mempool);
+        CFeeRate nFeeRateNeeded =
+            GetMinimumFeeRate(*this, coinControl, g_mempool);
 
         nFeeRet = Amount::zero();
         bool pick_new_inputs = true;
@@ -3147,7 +3130,8 @@
                 return false;
             }
 
-            Amount nFeeNeeded = GetMinimumFee(nBytes, coinControl, g_mempool);
+            Amount nFeeNeeded =
+                GetMinimumFee(*this, nBytes, coinControl, g_mempool);
 
             // If we made it here and we aren't even able to meet the relay fee
             // on the next pass, give up because we must be at the maximum
@@ -3175,7 +3159,7 @@
                     unsigned int tx_size_with_change =
                         nBytes + coin_selection_params.change_output_size + 2;
                     Amount fee_needed_with_change = GetMinimumFee(
-                        tx_size_with_change, coinControl, g_mempool);
+                        *this, tx_size_with_change, coinControl, g_mempool);
                     Amount minimum_value_for_change =
                         GetDustThreshold(change_prototype_txout, dustRelayFee);
                     if (nFeeRet >=
@@ -4351,6 +4335,62 @@
         }
     }
 
+    if (gArgs.IsArgSet("-mintxfee")) {
+        Amount n = Amount::zero();
+        if (!ParseMoney(gArgs.GetArg("-mintxfee", ""), n) ||
+            n == Amount::zero()) {
+            InitError(AmountErrMsg("mintxfee", gArgs.GetArg("-mintxfee", "")));
+            return nullptr;
+        }
+        if (n > HIGH_TX_FEE_PER_KB) {
+            InitWarning(AmountHighWarn("-mintxfee") + " " +
+                        _("This is the minimum transaction fee you pay on "
+                          "every transaction."));
+        }
+        walletInstance->m_min_fee = CFeeRate(n);
+    }
+
+    if (gArgs.IsArgSet("-fallbackfee")) {
+        Amount nFeePerK = Amount::zero();
+        if (!ParseMoney(gArgs.GetArg("-fallbackfee", ""), nFeePerK)) {
+            InitError(
+                strprintf(_("Invalid amount for -fallbackfee=<amount>: '%s'"),
+                          gArgs.GetArg("-fallbackfee", "")));
+            return nullptr;
+        }
+        if (nFeePerK > HIGH_TX_FEE_PER_KB) {
+            InitWarning(AmountHighWarn("-fallbackfee") + " " +
+                        _("This is the transaction fee you may pay when fee "
+                          "estimates are not available."));
+        }
+        walletInstance->m_fallback_fee = CFeeRate(nFeePerK);
+        // disable fallback fee in case value was set to 0, enable if non-null
+        // value
+        walletInstance->m_allow_fallback_fee = (nFeePerK != Amount::zero());
+    }
+    if (gArgs.IsArgSet("-paytxfee")) {
+        Amount nFeePerK = Amount::zero();
+        if (!ParseMoney(gArgs.GetArg("-paytxfee", ""), nFeePerK)) {
+            InitError(AmountErrMsg("paytxfee", gArgs.GetArg("-paytxfee", "")));
+            return nullptr;
+        }
+        if (nFeePerK > HIGH_TX_FEE_PER_KB) {
+            InitWarning(AmountHighWarn("-paytxfee") + " " +
+                        _("This is the transaction fee you will pay if you "
+                          "send a transaction."));
+        }
+        walletInstance->m_pay_tx_fee = CFeeRate(nFeePerK, 1000);
+        if (walletInstance->m_pay_tx_fee < ::minRelayTxFee) {
+            InitError(strprintf(_("Invalid amount for -paytxfee=<amount>: '%s' "
+                                  "(must be at least %s)"),
+                                gArgs.GetArg("-paytxfee", ""),
+                                ::minRelayTxFee.ToString()));
+            return nullptr;
+        }
+    }
+    walletInstance->m_spend_zero_conf_change =
+        gArgs.GetBoolArg("-spendzeroconfchange", DEFAULT_SPEND_ZEROCONF_CHANGE);
+
     LogPrintf(" wallet      %15dms\n", GetTimeMillis() - nStart);
 
     // Try to top up keypool. No-op if the wallet is locked.
diff --git a/test/functional/wallet_multiwallet.py b/test/functional/wallet_multiwallet.py
--- a/test/functional/wallet_multiwallet.py
+++ b/test/functional/wallet_multiwallet.py
@@ -169,6 +169,13 @@
         assert_equal(batch[0]["result"]["chain"], "regtest")
         assert_equal(batch[1]["result"]["walletname"], "w1")
 
+        self.log.info('Check for per-wallet settxfee call')
+        assert_equal(w1.getwalletinfo()['paytxfee'], 0)
+        assert_equal(w2.getwalletinfo()['paytxfee'], 0)
+        w2.settxfee(4.0)
+        assert_equal(w1.getwalletinfo()['paytxfee'], 0)
+        assert_equal(w2.getwalletinfo()['paytxfee'], 4.0)
+
 
 if __name__ == '__main__':
     MultiWalletTest().main()