diff --git a/src/common/messages.cpp b/src/common/messages.cpp
index e558442f427..ae3672bffb2 100644
--- a/src/common/messages.cpp
+++ b/src/common/messages.cpp
@@ -28,12 +28,9 @@ namespace common {
 std::string StringForFeeReason(FeeReason reason)
 {
     static const std::map<FeeReason, std::string> fee_reason_strings = {
-        {FeeReason::NONE, "None"},
-        {FeeReason::HALF_ESTIMATE, "Half Target 60% Threshold"},
-        {FeeReason::FULL_ESTIMATE, "Target 85% Threshold"},
-        {FeeReason::DOUBLE_ESTIMATE, "Double Target 95% Threshold"},
-        {FeeReason::CONSERVATIVE, "Conservative Double Target longer horizon"},
+        {FeeReason::FEE_RATE_ESTIMATOR, "Fee Rate Estimator"},
         {FeeReason::MEMPOOL_MIN, "Mempool Min Fee"},
+        {FeeReason::USER_SPECIFIED, "User Specified Fee"},
         {FeeReason::FALLBACK, "Fallback fee"},
         {FeeReason::REQUIRED, "Minimum Required Fee"},
     };
@@ -44,6 +41,23 @@ std::string StringForFeeReason(FeeReason reason)
     return reason_string->second;
 }
 
+std::string StringForBlockPolicyEstimateReason(BlockPolicyEstimateReason reason)
+{
+    switch (reason) {
+    case BlockPolicyEstimateReason::NONE:
+        return "None";
+    case BlockPolicyEstimateReason::HALF_ESTIMATE:
+        return "Half Target 60% Threshold";
+    case BlockPolicyEstimateReason::FULL_ESTIMATE:
+        return "Target 85% Threshold";
+    case BlockPolicyEstimateReason::DOUBLE_ESTIMATE:
+        return "Double Target 95% Threshold";
+    case BlockPolicyEstimateReason::CONSERVATIVE:
+        return "Conservative Double Target longer horizon";
+    } // no default case, so the compiler can warn about missing cases
+    assert(false);
+}
+
 const std::vector<std::pair<std::string, FeeEstimateMode>>& FeeModeMap()
 {
     static const std::vector<std::pair<std::string, FeeEstimateMode>> FEE_MODES = {
diff --git a/src/common/messages.h b/src/common/messages.h
index 6dc3212f8c9..4b7e42d953c 100644
--- a/src/common/messages.h
+++ b/src/common/messages.h
@@ -18,7 +18,7 @@
 struct bilingual_str;
 enum class FeeEstimateMode;
 enum class FeeReason;
-
+enum class BlockPolicyEstimateReason;
 namespace node {
 enum class TransactionError;
 } // namespace node
@@ -28,6 +28,7 @@ enum class PSBTError;
 
 bool FeeModeFromString(std::string_view mode_string, FeeEstimateMode& fee_estimate_mode);
 std::string StringForFeeReason(FeeReason reason);
+std::string StringForBlockPolicyEstimateReason(BlockPolicyEstimateReason reason);
 std::string FeeModes(const std::string& delimiter);
 std::string FeeModeInfo(std::pair<std::string, FeeEstimateMode>& mode);
 std::string FeeModesDetail(std::string default_info);
diff --git a/src/interfaces/wallet.h b/src/interfaces/wallet.h
index f78e3da03dd..d34fc62aca8 100644
--- a/src/interfaces/wallet.h
+++ b/src/interfaces/wallet.h
@@ -22,6 +22,7 @@
 #include <functional>
 #include <map>
 #include <memory>
+#include <optional>
 #include <string>
 #include <tuple>
 #include <type_traits>
@@ -242,7 +243,7 @@ public:
     //! Get minimum fee.
     virtual CAmount getMinimumFee(unsigned int tx_bytes,
         const wallet::CCoinControl& coin_control,
-        int* returned_target,
+        std::optional<int>* returned_target,
         FeeReason* reason) = 0;
 
     //! Get tx confirm target.
diff --git a/src/policy/fees/block_policy_estimator.cpp b/src/policy/fees/block_policy_estimator.cpp
index 1434c5de070..f4ed120eecc 100644
--- a/src/policy/fees/block_policy_estimator.cpp
+++ b/src/policy/fees/block_policy_estimator.cpp
@@ -919,7 +919,7 @@ CFeeRate CBlockPolicyEstimator::estimateSmartFee(int confTarget, FeeCalculation
     double halfEst = estimateCombinedFee(confTarget/2, HALF_SUCCESS_PCT, true, &tempResult);
     if (feeCalc) {
         feeCalc->est = tempResult;
-        feeCalc->reason = FeeReason::HALF_ESTIMATE;
+        feeCalc->reason = BlockPolicyEstimateReason::HALF_ESTIMATE;
     }
     median = halfEst;
     double actualEst = estimateCombinedFee(confTarget, SUCCESS_PCT, true, &tempResult);
@@ -927,7 +927,7 @@ CFeeRate CBlockPolicyEstimator::estimateSmartFee(int confTarget, FeeCalculation
         median = actualEst;
         if (feeCalc) {
             feeCalc->est = tempResult;
-            feeCalc->reason = FeeReason::FULL_ESTIMATE;
+            feeCalc->reason = BlockPolicyEstimateReason::FULL_ESTIMATE;
         }
     }
     double doubleEst = estimateCombinedFee(2 * confTarget, DOUBLE_SUCCESS_PCT, !conservative, &tempResult);
@@ -935,7 +935,7 @@ CFeeRate CBlockPolicyEstimator::estimateSmartFee(int confTarget, FeeCalculation
         median = doubleEst;
         if (feeCalc) {
             feeCalc->est = tempResult;
-            feeCalc->reason = FeeReason::DOUBLE_ESTIMATE;
+            feeCalc->reason = BlockPolicyEstimateReason::DOUBLE_ESTIMATE;
         }
     }
 
@@ -945,7 +945,7 @@ CFeeRate CBlockPolicyEstimator::estimateSmartFee(int confTarget, FeeCalculation
             median = consEst;
             if (feeCalc) {
                 feeCalc->est = tempResult;
-                feeCalc->reason = FeeReason::CONSERVATIVE;
+                feeCalc->reason = BlockPolicyEstimateReason::CONSERVATIVE;
             }
         }
     }
diff --git a/src/policy/fees/block_policy_estimator.h b/src/policy/fees/block_policy_estimator.h
index a87970cd4dc..cd6961c4013 100644
--- a/src/policy/fees/block_policy_estimator.h
+++ b/src/policy/fees/block_policy_estimator.h
@@ -56,15 +56,12 @@ inline constexpr auto ALL_FEE_ESTIMATE_HORIZONS = std::array{
 std::string StringForFeeEstimateHorizon(FeeEstimateHorizon horizon);
 
 /* Enumeration of reason for returned fee estimate */
-enum class FeeReason {
+enum class BlockPolicyEstimateReason {
     NONE,
     HALF_ESTIMATE,
     FULL_ESTIMATE,
     DOUBLE_ESTIMATE,
     CONSERVATIVE,
-    MEMPOOL_MIN,
-    FALLBACK,
-    REQUIRED,
 };
 
 /* Used to return detailed information about a feerate bucket */
@@ -90,7 +87,7 @@ struct EstimationResult
 struct FeeCalculation
 {
     EstimationResult est;
-    FeeReason reason = FeeReason::NONE;
+    BlockPolicyEstimateReason reason = BlockPolicyEstimateReason::NONE;
     int desiredTarget = 0;
     int returnedTarget = 0;
     unsigned int best_height{0};
diff --git a/src/qt/sendcoinsdialog.cpp b/src/qt/sendcoinsdialog.cpp
index 7c8c04366f7..9bc0ff48df0 100644
--- a/src/qt/sendcoinsdialog.cpp
+++ b/src/qt/sendcoinsdialog.cpp
@@ -21,17 +21,18 @@
 #include <key_io.h>
 #include <node/interface_ui.h>
 #include <node/types.h>
-#include <policy/fees/block_policy_estimator.h>
 #include <txmempool.h>
 #include <validation.h>
 #include <wallet/coincontrol.h>
 #include <wallet/fees.h>
+#include <wallet/types.h>
 #include <wallet/wallet.h>
 
 #include <array>
 #include <chrono>
 #include <fstream>
 #include <memory>
+#include <optional>
 
 #include <QFontMetrics>
 #include <QScrollBar>
@@ -837,7 +838,7 @@ void SendCoinsDialog::updateSmartFeeLabel()
         return;
     updateCoinControlState();
     m_coin_control->m_feerate.reset(); // Explicitly use only fee estimation rate for smart fee labels
-    int returned_target;
+    std::optional<int> returned_target;
     FeeReason reason;
     CFeeRate feeRate = CFeeRate(model->wallet().getMinimumFee(1000, *m_coin_control, &returned_target, &reason));
 
@@ -855,7 +856,10 @@ void SendCoinsDialog::updateSmartFeeLabel()
     else
     {
         ui->labelSmartFee2->hide();
-        ui->labelFeeEstimation->setText(tr("Estimated to begin confirmation within %n block(s).", "", returned_target));
+        ui->labelFeeEstimation->setText("");
+        if (returned_target) {
+            ui->labelFeeEstimation->setText(tr("Estimated to begin confirmation within %n block(s).", "", *returned_target));
+        }
         ui->fallbackFeeWarningLabel->setVisible(false);
     }
 
diff --git a/src/test/fuzz/fees.cpp b/src/test/fuzz/fees.cpp
index 1940e342c67..5c5f14ffff6 100644
--- a/src/test/fuzz/fees.cpp
+++ b/src/test/fuzz/fees.cpp
@@ -8,12 +8,14 @@
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
 #include <test/fuzz/util.h>
+#include <util/fees.h>
 
 #include <cstdint>
 #include <string>
 #include <vector>
 
 using common::StringForFeeReason;
+using common::StringForBlockPolicyEstimateReason;
 
 FUZZ_TARGET(fees)
 {
@@ -26,6 +28,8 @@ FUZZ_TARGET(fees)
         const CAmount rounded_fee = fee_filter_rounder.round(current_minimum_fee);
         assert(MoneyRange(rounded_fee));
     }
-    const FeeReason fee_reason = fuzzed_data_provider.PickValueInArray({FeeReason::NONE, FeeReason::HALF_ESTIMATE, FeeReason::FULL_ESTIMATE, FeeReason::DOUBLE_ESTIMATE, FeeReason::CONSERVATIVE, FeeReason::MEMPOOL_MIN, FeeReason::FALLBACK, FeeReason::REQUIRED});
+    const FeeReason fee_reason = fuzzed_data_provider.PickValueInArray({FeeReason::FEE_RATE_ESTIMATOR, FeeReason::MEMPOOL_MIN, FeeReason::USER_SPECIFIED, FeeReason::FALLBACK, FeeReason::REQUIRED});
     (void)StringForFeeReason(fee_reason);
+    const BlockPolicyEstimateReason block_policy_fee_reason = fuzzed_data_provider.PickValueInArray({BlockPolicyEstimateReason::NONE, BlockPolicyEstimateReason::HALF_ESTIMATE, BlockPolicyEstimateReason::FULL_ESTIMATE, BlockPolicyEstimateReason::DOUBLE_ESTIMATE, BlockPolicyEstimateReason::CONSERVATIVE});
+    (void)StringForBlockPolicyEstimateReason(block_policy_fee_reason);
 }
diff --git a/src/util/fees.h b/src/util/fees.h
index 6edcb772d24..85c3d59d462 100644
--- a/src/util/fees.h
+++ b/src/util/fees.h
@@ -12,4 +12,13 @@ enum class FeeEstimateMode {
     CONSERVATIVE, //!< Force estimateSmartFee to use conservative estimates
 };
 
+/* Used to determine the reason a wallet selected a transaction fee rate */
+enum class FeeReason {
+    FEE_RATE_ESTIMATOR,
+    MEMPOOL_MIN,
+    USER_SPECIFIED,
+    FALLBACK,
+    REQUIRED,
+};
+
 #endif // BITCOIN_UTIL_FEES_H
diff --git a/src/wallet/coincontrol.h b/src/wallet/coincontrol.h
index d30cbe1c519..53fc0e8fcf0 100644
--- a/src/wallet/coincontrol.h
+++ b/src/wallet/coincontrol.h
@@ -7,7 +7,6 @@
 
 #include <outputtype.h>
 #include <policy/feerate.h>
-#include <policy/fees/block_policy_estimator.h>
 #include <primitives/transaction.h>
 #include <script/keyorigin.h>
 #include <script/signingprovider.h>
diff --git a/src/wallet/feebumper.cpp b/src/wallet/feebumper.cpp
index c3e422b371a..12197165be0 100644
--- a/src/wallet/feebumper.cpp
+++ b/src/wallet/feebumper.cpp
@@ -8,7 +8,6 @@
 #include <common/system.h>
 #include <consensus/validation.h>
 #include <interfaces/chain.h>
-#include <policy/fees/block_policy_estimator.h>
 #include <policy/policy.h>
 #include <util/moneystr.h>
 #include <util/rbf.h>
@@ -139,7 +138,7 @@ static CFeeRate EstimateFeeRate(const CWallet& wallet, const CWalletTx& wtx, con
     feerate += std::max(node_incremental_relay_fee, wallet_incremental_relay_fee);
 
     // Fee rate must also be at least the wallet's GetMinimumFeeRate
-    CFeeRate min_feerate(GetMinimumFeeRate(wallet, coin_control, /*feeCalc=*/nullptr));
+    CFeeRate min_feerate(GetMinimumFeeRate(wallet, coin_control).fee_rate);
 
     // Set the required fee rate for the replacement transaction in coin control.
     return std::max(feerate, min_feerate);
diff --git a/src/wallet/fees.cpp b/src/wallet/fees.cpp
index e2bb2227919..f5c4e62e5bd 100644
--- a/src/wallet/fees.cpp
+++ b/src/wallet/fees.cpp
@@ -5,9 +5,13 @@
 
 #include <wallet/fees.h>
 
+#include <policy/feerate.h>
+#include <policy/fees/block_policy_estimator.h>
+#include <util/fees.h>
 #include <wallet/coincontrol.h>
 #include <wallet/wallet.h>
 
+#include <optional>
 
 namespace wallet {
 CAmount GetRequiredFee(const CWallet& wallet, unsigned int nTxBytes)
@@ -16,9 +20,9 @@ CAmount GetRequiredFee(const CWallet& wallet, unsigned int nTxBytes)
 }
 
 
-CAmount GetMinimumFee(const CWallet& wallet, unsigned int nTxBytes, const CCoinControl& coin_control, FeeCalculation* feeCalc)
+CAmount GetMinimumFee(const MinimumFeeRateResult& min_fee_rate, unsigned int nTxBytes)
 {
-    return GetMinimumFeeRate(wallet, coin_control, feeCalc).GetFee(static_cast<int32_t>(nTxBytes));
+    return min_fee_rate.fee_rate.GetFee(static_cast<int32_t>(nTxBytes));
 }
 
 CFeeRate GetRequiredFeeRate(const CWallet& wallet)
@@ -26,7 +30,7 @@ CFeeRate GetRequiredFeeRate(const CWallet& wallet)
     return std::max(wallet.m_min_fee, wallet.chain().relayMinFee());
 }
 
-CFeeRate GetMinimumFeeRate(const CWallet& wallet, const CCoinControl& coin_control, FeeCalculation* feeCalc)
+MinimumFeeRateResult GetMinimumFeeRate(const CWallet& wallet, const CCoinControl& coin_control)
 {
     /* User control of how to calculate fee uses the following parameter precedence:
        1. coin_control.m_feerate
@@ -34,45 +38,53 @@ CFeeRate GetMinimumFeeRate(const CWallet& wallet, const CCoinControl& coin_contr
        3. m_confirm_target (user-set member variable of wallet)
        The first parameter that is set is used.
     */
-    CFeeRate feerate_needed;
     if (coin_control.m_feerate) { // 1.
-        feerate_needed = *(coin_control.m_feerate);
+        CFeeRate fee_rate{*coin_control.m_feerate};
         // Allow to override automatic min/max check over coin control instance
-        if (coin_control.fOverrideFeeRate) return feerate_needed;
-    }
-    else { // 2. or 3.
-        // We will use smart fee estimation
-        unsigned int target = coin_control.m_confirm_target ? *coin_control.m_confirm_target : wallet.m_confirm_target;
-        // By default estimates are economical iff we are signaling opt-in-RBF
-        bool conservative_estimate = !coin_control.m_signal_bip125_rbf.value_or(wallet.m_signal_rbf);
-        // Allow to override the default fee estimate mode over the CoinControl instance
-        if (coin_control.m_fee_mode == FeeEstimateMode::CONSERVATIVE) conservative_estimate = true;
-        else if (coin_control.m_fee_mode == FeeEstimateMode::ECONOMICAL) conservative_estimate = false;
+        if (coin_control.fOverrideFeeRate) return {fee_rate, FeeReason::USER_SPECIFIED, std::nullopt};
 
-        feerate_needed = wallet.chain().estimateSmartFee(target, conservative_estimate, feeCalc);
-        if (feerate_needed == CFeeRate(0)) {
-            // if we don't have enough data for estimateSmartFee, then use fallback fee
-            feerate_needed = wallet.m_fallback_fee;
-            if (feeCalc) feeCalc->reason = FeeReason::FALLBACK;
+        CFeeRate required_feerate = GetRequiredFeeRate(wallet);
+        if (required_feerate > fee_rate) return {required_feerate, FeeReason::REQUIRED, std::nullopt};
 
-            // directly return if fallback fee is disabled (feerate 0 == disabled)
-            if (wallet.m_fallback_fee == CFeeRate(0)) return feerate_needed;
-        }
-        // Obey mempool min fee when using smart fee estimation
-        CFeeRate min_mempool_feerate = wallet.chain().mempoolMinFee();
-        if (feerate_needed < min_mempool_feerate) {
-            feerate_needed = min_mempool_feerate;
-            if (feeCalc) feeCalc->reason = FeeReason::MEMPOOL_MIN;
-        }
+        return {fee_rate, FeeReason::USER_SPECIFIED, std::nullopt};
+    }
+
+    // We will use smart fee estimation
+    unsigned int target = coin_control.m_confirm_target ? *coin_control.m_confirm_target : wallet.m_confirm_target;
+    // By default estimates are economical iff we are signaling opt-in-RBF
+    bool conservative_estimate = !coin_control.m_signal_bip125_rbf.value_or(wallet.m_signal_rbf);
+    // Allow to override the default fee estimate mode over the CoinControl instance
+    if (coin_control.m_fee_mode == FeeEstimateMode::CONSERVATIVE)
+        conservative_estimate = true;
+    else if (coin_control.m_fee_mode == FeeEstimateMode::ECONOMICAL)
+        conservative_estimate = false;
+
+    FeeCalculation feeCalc;
+    CFeeRate fee_rate{wallet.chain().estimateSmartFee(target, conservative_estimate, &feeCalc)};
+    FeeReason fee_reason{FeeReason::FEE_RATE_ESTIMATOR};
+    // Only fee rate estimator results have a returned target.
+    std::optional<int> returned_target{feeCalc.returnedTarget};
+    if (fee_rate == CFeeRate(0)) {
+        // if we don't have enough data for estimateSmartFee, then use fallback fee
+        fee_rate = wallet.m_fallback_fee;
+        fee_reason = FeeReason::FALLBACK;
+        returned_target = std::nullopt;
+        // directly return if fallback fee is disabled (feerate 0 == disabled)
+        if (wallet.m_fallback_fee == CFeeRate(0)) return {fee_rate, FeeReason::FALLBACK, std::nullopt};
+    }
+
+    // Obey mempool min fee when using smart fee estimation or fallback fee
+    CFeeRate min_mempool_feerate = wallet.chain().mempoolMinFee();
+    if (fee_rate < min_mempool_feerate) {
+        fee_rate = min_mempool_feerate;
+        fee_reason = FeeReason::MEMPOOL_MIN;
+        returned_target = std::nullopt;
     }
 
-    // prevent user from paying a fee below the required fee rate
     CFeeRate required_feerate = GetRequiredFeeRate(wallet);
-    if (required_feerate > feerate_needed) {
-        feerate_needed = required_feerate;
-        if (feeCalc) feeCalc->reason = FeeReason::REQUIRED;
-    }
-    return feerate_needed;
+    if (required_feerate > fee_rate) return {required_feerate, FeeReason::REQUIRED, std::nullopt};
+
+    return {fee_rate, fee_reason, returned_target};
 }
 
 CFeeRate GetDiscardRate(const CWallet& wallet)
diff --git a/src/wallet/fees.h b/src/wallet/fees.h
index b815d1c0004..90a371e1de7 100644
--- a/src/wallet/fees.h
+++ b/src/wallet/fees.h
@@ -7,9 +7,9 @@
 #define BITCOIN_WALLET_FEES_H
 
 #include <consensus/amount.h>
+#include <wallet/types.h>
 
 class CFeeRate;
-struct FeeCalculation;
 
 namespace wallet {
 class CCoinControl;
@@ -22,10 +22,9 @@ class CWallet;
 CAmount GetRequiredFee(const CWallet& wallet, unsigned int nTxBytes);
 
 /**
- * Estimate the minimum fee considering user set parameters
- * and the required fee
+ * Return the minimum fee for this size given a fee rate result.
  */
-CAmount GetMinimumFee(const CWallet& wallet, unsigned int nTxBytes, const CCoinControl& coin_control, FeeCalculation* feeCalc);
+CAmount GetMinimumFee(const MinimumFeeRateResult& min_fee_rate, unsigned int nTxBytes);
 
 /**
  * Return the minimum required feerate taking into account the
@@ -37,7 +36,7 @@ CFeeRate GetRequiredFeeRate(const CWallet& wallet);
  * Estimate the minimum fee rate considering user set parameters
  * and the required fee
  */
-CFeeRate GetMinimumFeeRate(const CWallet& wallet, const CCoinControl& coin_control, FeeCalculation* feeCalc);
+MinimumFeeRateResult GetMinimumFeeRate(const CWallet& wallet, const CCoinControl& coin_control);
 
 /**
  * Return the maximum feerate for discarding change.
diff --git a/src/wallet/interfaces.cpp b/src/wallet/interfaces.cpp
index b5ee124c3d8..0be97c460b2 100644
--- a/src/wallet/interfaces.cpp
+++ b/src/wallet/interfaces.cpp
@@ -9,7 +9,6 @@
 #include <interfaces/chain.h>
 #include <interfaces/handler.h>
 #include <node/types.h>
-#include <policy/fees/block_policy_estimator.h>
 #include <primitives/transaction.h>
 #include <rpc/server.h>
 #include <scheduler.h>
@@ -469,14 +468,13 @@ public:
     CAmount getRequiredFee(unsigned int tx_bytes) override { return GetRequiredFee(*m_wallet, tx_bytes); }
     CAmount getMinimumFee(unsigned int tx_bytes,
         const CCoinControl& coin_control,
-        int* returned_target,
+        std::optional<int>* returned_target,
         FeeReason* reason) override
     {
-        FeeCalculation fee_calc;
-        CAmount result;
-        result = GetMinimumFee(*m_wallet, tx_bytes, coin_control, &fee_calc);
-        if (returned_target) *returned_target = fee_calc.returnedTarget;
-        if (reason) *reason = fee_calc.reason;
+        auto min_fee_rate{GetMinimumFeeRate(*m_wallet, coin_control)};
+        auto result = GetMinimumFee(min_fee_rate, tx_bytes);
+        if (returned_target) *returned_target = min_fee_rate.returned_target;
+        if (reason) *reason = min_fee_rate.fee_reason;
         return result;
     }
     unsigned int getConfirmTarget() override { return m_wallet->m_confirm_target; }
diff --git a/src/wallet/rpc/spend.cpp b/src/wallet/rpc/spend.cpp
index cb90dfac19f..bfe5851ad7c 100644
--- a/src/wallet/rpc/spend.cpp
+++ b/src/wallet/rpc/spend.cpp
@@ -195,7 +195,7 @@ UniValue SendMoney(CWallet& wallet, const CCoinControl &coin_control, std::vecto
     if (verbose) {
         UniValue entry(UniValue::VOBJ);
         entry.pushKV("txid", tx->GetHash().GetHex());
-        entry.pushKV("fee_reason", StringForFeeReason(res->fee_calc.reason));
+        entry.pushKV("fee_reason", StringForFeeReason(res->fee_reason));
         return entry;
     }
     return tx->GetHash().GetHex();
@@ -272,7 +272,7 @@ RPCMethod sendtoaddress()
                         RPCResult::Type::OBJ, "", "",
                         {
                             {RPCResult::Type::STR_HEX, "txid", "The transaction id."},
-                            {RPCResult::Type::STR, "fee_reason", "The transaction fee reason."}
+                            {RPCResult::Type::STR, "fee_reason", "The reason the wallet selected this fee rate (e.g. fee rate estimator, mempool minimum, fallback, or minimum required)."}
                         },
                     },
                 },
@@ -382,7 +382,7 @@ RPCMethod sendmany()
                         {
                             {RPCResult::Type::STR_HEX, "txid", "The transaction id for the send. Only 1 transaction is created regardless of\n"
                 "the number of addresses."},
-                            {RPCResult::Type::STR, "fee_reason", "The transaction fee reason."}
+                            {RPCResult::Type::STR, "fee_reason", "The reason the wallet selected this fee rate (e.g. fee rate estimator, mempool minimum, fallback, or minimum required)."}
                         },
                     },
                 },
@@ -1439,8 +1439,7 @@ RPCMethod sendall()
 
             const bool rbf{options.exists("replaceable") ? options["replaceable"].get_bool() : pwallet->m_signal_rbf};
 
-            FeeCalculation fee_calc_out;
-            CFeeRate fee_rate{GetMinimumFeeRate(*pwallet, coin_control, &fee_calc_out)};
+            auto [fee_rate, fee_reason, returned_target] = GetMinimumFeeRate(*pwallet, coin_control);
             // Do not, ever, assume that it's fine to change the fee rate if the user has explicitly
             // provided one
             if (coin_control.m_feerate && fee_rate > *coin_control.m_feerate) {
@@ -1448,14 +1447,14 @@ RPCMethod sendall()
                 auto msg{strprintf("Fee rate (%s) is lower than the minimum fee rate setting (%s).",
                     coin_control.m_feerate->ToString(feerate_format),
                     fee_rate.ToString(feerate_format))};
-                if (fee_calc_out.reason == FeeReason::REQUIRED) {
+                if (fee_reason == FeeReason::REQUIRED) {
                     msg += strprintf("\nConsider modifying -mintxfee (%s) or -minrelaytxfee (%s).",
                         pwallet->m_min_fee.ToString(feerate_format),
                         pwallet->chain().relayMinFee().ToString(feerate_format));
                 }
                 throw JSONRPCError(RPC_INVALID_PARAMETER, msg);
             }
-            if (fee_calc_out.reason == FeeReason::FALLBACK && !pwallet->m_allow_fallback_fee) {
+            if (fee_reason == FeeReason::FALLBACK && !pwallet->m_allow_fallback_fee) {
                 // eventually allow a fallback fee
                 throw JSONRPCError(RPC_WALLET_ERROR, "Fee estimation failed. Fallbackfee is disabled. Wait a few blocks or enable -fallbackfee.");
             }
diff --git a/src/wallet/spend.cpp b/src/wallet/spend.cpp
index 0f445f6db5c..cf5be440f73 100644
--- a/src/wallet/spend.cpp
+++ b/src/wallet/spend.cpp
@@ -1151,8 +1151,8 @@ static util::Result<CreatedTransactionResult> CreateTransactionInternal(
     coin_selection_params.m_discard_feerate = GetDiscardRate(wallet);
 
     // Get the fee rate to use effective values in coin selection
-    FeeCalculation feeCalc;
-    coin_selection_params.m_effective_feerate = GetMinimumFeeRate(wallet, coin_control, &feeCalc);
+    auto min_fee_rate{GetMinimumFeeRate(wallet, coin_control)};
+    coin_selection_params.m_effective_feerate = min_fee_rate.fee_rate;
     // Do not, ever, assume that it's fine to change the fee rate if the user has explicitly
     // provided one
     if (coin_control.m_feerate && coin_selection_params.m_effective_feerate > *coin_control.m_feerate) {
@@ -1160,7 +1160,7 @@ static util::Result<CreatedTransactionResult> CreateTransactionInternal(
         auto msg{strprintf(_("Fee rate (%s) is lower than the minimum fee rate setting (%s)."),
             coin_control.m_feerate->ToString(feerate_format),
             coin_selection_params.m_effective_feerate.ToString(feerate_format))};
-        if (feeCalc.reason == FeeReason::REQUIRED) {
+        if (min_fee_rate.fee_reason == FeeReason::REQUIRED) {
             msg += strprintf(_("\nConsider modifying %s (%s) or %s (%s)."),
                 "-mintxfee",
                 wallet.m_min_fee.ToString(feerate_format),
@@ -1169,7 +1169,7 @@ static util::Result<CreatedTransactionResult> CreateTransactionInternal(
         }
         return util::Error{msg};
     }
-    if (feeCalc.reason == FeeReason::FALLBACK && !wallet.m_allow_fallback_fee) {
+    if (min_fee_rate.fee_reason == FeeReason::FALLBACK && !wallet.m_allow_fallback_fee) {
         // eventually allow a fallback fee
         return util::Error{strprintf(_("Fee estimation failed. Fallbackfee is disabled. Wait a few blocks or enable %s."), "-fallbackfee")};
     }
@@ -1434,15 +1434,9 @@ static util::Result<CreatedTransactionResult> CreateTransactionInternal(
     reservedest.KeepDestination();
 
     wallet.WalletLogPrintf("Coin Selection: Algorithm:%s, Waste Metric Score:%d\n", GetAlgorithmName(result.GetAlgo()), result.GetWaste());
-    wallet.WalletLogPrintf("Fee Calculation: Fee:%d Bytes:%u Tgt:%d (requested %d) Reason:\"%s\" Decay %.5f: Estimation: (%g - %g) %.2f%% %.1f/(%.1f %d mem %.1f out) Fail: (%g - %g) %.2f%% %.1f/(%.1f %d mem %.1f out)\n",
-              current_fee, nBytes, feeCalc.returnedTarget, feeCalc.desiredTarget, StringForFeeReason(feeCalc.reason), feeCalc.est.decay,
-              feeCalc.est.pass.start, feeCalc.est.pass.end,
-              (feeCalc.est.pass.totalConfirmed + feeCalc.est.pass.inMempool + feeCalc.est.pass.leftMempool) > 0.0 ? 100 * feeCalc.est.pass.withinTarget / (feeCalc.est.pass.totalConfirmed + feeCalc.est.pass.inMempool + feeCalc.est.pass.leftMempool) : 0.0,
-              feeCalc.est.pass.withinTarget, feeCalc.est.pass.totalConfirmed, feeCalc.est.pass.inMempool, feeCalc.est.pass.leftMempool,
-              feeCalc.est.fail.start, feeCalc.est.fail.end,
-              (feeCalc.est.fail.totalConfirmed + feeCalc.est.fail.inMempool + feeCalc.est.fail.leftMempool) > 0.0 ? 100 * feeCalc.est.fail.withinTarget / (feeCalc.est.fail.totalConfirmed + feeCalc.est.fail.inMempool + feeCalc.est.fail.leftMempool) : 0.0,
-              feeCalc.est.fail.withinTarget, feeCalc.est.fail.totalConfirmed, feeCalc.est.fail.inMempool, feeCalc.est.fail.leftMempool);
-    return CreatedTransactionResult(tx, current_fee, change_pos, feeCalc);
+    wallet.WalletLogPrintf("Fee Calculation: Fee:%d Bytes:%u, Source: %s\n",
+                           current_fee, nBytes, StringForFeeReason(min_fee_rate.fee_reason));
+    return CreatedTransactionResult(tx, current_fee, change_pos, min_fee_rate.fee_reason);
 }
 
 util::Result<CreatedTransactionResult> CreateTransaction(
diff --git a/src/wallet/spend.h b/src/wallet/spend.h
index b013a3fabdf..e64e73179ca 100644
--- a/src/wallet/spend.h
+++ b/src/wallet/spend.h
@@ -6,7 +6,6 @@
 #define BITCOIN_WALLET_SPEND_H
 
 #include <consensus/amount.h>
-#include <policy/fees/block_policy_estimator.h>
 #include <util/result.h>
 #include <wallet/coinselection.h>
 #include <wallet/transaction.h>
diff --git a/src/wallet/test/fuzz/fees.cpp b/src/wallet/test/fuzz/fees.cpp
index 36c1f56b0a9..4886b2ab17c 100644
--- a/src/wallet/test/fuzz/fees.cpp
+++ b/src/wallet/test/fuzz/fees.cpp
@@ -2,18 +2,22 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <policy/fees/block_policy_estimator.h>
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
 #include <test/fuzz/util.h>
 #include <test/util/setup_common.h>
 #include <test/util/time.h>
 #include <test/util/txmempool.h>
+#include <util/fees.h>
 #include <validation.h>
 #include <wallet/coincontrol.h>
 #include <wallet/fees.h>
 #include <wallet/test/util.h>
 #include <wallet/wallet.h>
 
+#include <optional>
+
 namespace wallet {
 namespace {
 
@@ -115,11 +119,20 @@ FUZZ_TARGET(wallet_fees, .init = initialize_setup)
     if (fuzzed_data_provider.ConsumeBool()) {
         coin_control.m_fee_mode = fuzzed_data_provider.ConsumeBool() ? FeeEstimateMode::CONSERVATIVE : FeeEstimateMode::ECONOMICAL;
     }
-
-    FeeCalculation fee_calculation;
-    FeeCalculation* maybe_fee_calculation{fuzzed_data_provider.ConsumeBool() ? nullptr : &fee_calculation};
-    (void)GetMinimumFeeRate(wallet, coin_control, maybe_fee_calculation);
-    (void)GetMinimumFee(wallet, tx_bytes, coin_control, maybe_fee_calculation);
+    FeeReason fee_reason{FeeReason::FEE_RATE_ESTIMATOR};
+    if (fuzzed_data_provider.ConsumeBool()) {
+        fee_reason = fuzzed_data_provider.PickValueInArray({FeeReason::FEE_RATE_ESTIMATOR, FeeReason::MEMPOOL_MIN, FeeReason::USER_SPECIFIED, FeeReason::FALLBACK, FeeReason::REQUIRED});
+    }
+    std::optional<int> returned_target;
+    if (fuzzed_data_provider.ConsumeBool()) {
+        returned_target = fuzzed_data_provider.ConsumeIntegralInRange<int>(1, 999'000);
+    }
+    MinimumFeeRateResult min_fee_rate{
+        CFeeRate{ConsumeMoney(fuzzed_data_provider, /*max=*/COIN)},
+        fee_reason,
+        returned_target};
+    (void)GetMinimumFeeRate(wallet, coin_control);
+    (void)GetMinimumFee(min_fee_rate, tx_bytes);
 }
 } // namespace
 } // namespace wallet
diff --git a/src/wallet/test/spend_tests.cpp b/src/wallet/test/spend_tests.cpp
index 218792ff033..7e0a5bd67b5 100644
--- a/src/wallet/test/spend_tests.cpp
+++ b/src/wallet/test/spend_tests.cpp
@@ -4,7 +4,6 @@
 
 #include <consensus/amount.h>
 #include <key.h>
-#include <policy/fees/block_policy_estimator.h>
 #include <script/solver.h>
 #include <validation.h>
 #include <wallet/coincontrol.h>
diff --git a/src/wallet/types.h b/src/wallet/types.h
index e4cbab3b241..d4683e7285f 100644
--- a/src/wallet/types.h
+++ b/src/wallet/types.h
@@ -14,10 +14,25 @@
 #ifndef BITCOIN_WALLET_TYPES_H
 #define BITCOIN_WALLET_TYPES_H
 
-#include <policy/fees/block_policy_estimator.h>
+#include <consensus/amount.h>
+#include <policy/feerate.h>
+#include <primitives/transaction.h>
+#include <util/fees.h>
 #include <util/translation.h>
 
+#include <optional>
+#include <utility>
+
 namespace wallet {
+struct MinimumFeeRateResult {
+    CFeeRate fee_rate;
+    FeeReason fee_reason;
+    std::optional<int> returned_target;
+
+    MinimumFeeRateResult(CFeeRate fee_rate, FeeReason fee_reason, std::optional<int> returned_target)
+        : fee_rate{fee_rate}, fee_reason{fee_reason}, returned_target{std::move(returned_target)} {}
+};
+
 /**
  * Address purpose field that has been been stored with wallet sending and
  * receiving addresses since BIP70 payment protocol support was added in
@@ -36,11 +51,11 @@ struct CreatedTransactionResult
 {
     CTransactionRef tx;
     CAmount fee;
-    FeeCalculation fee_calc;
+    FeeReason fee_reason;
     std::optional<unsigned int> change_pos;
 
-    CreatedTransactionResult(CTransactionRef _tx, CAmount _fee, std::optional<unsigned int> _change_pos, const FeeCalculation& _fee_calc)
-            : tx(_tx), fee(_fee), fee_calc(_fee_calc), change_pos(_change_pos) {}
+    CreatedTransactionResult(CTransactionRef _tx, CAmount _fee, std::optional<unsigned int> _change_pos, FeeReason _fee_reason)
+        : tx(_tx), fee(_fee), fee_reason(_fee_reason), change_pos(_change_pos) {}
 };
 
 //! Machine-readable wallet error codes.