diff --git a/include/xrpl/ledger/helpers/LendingHelpers.h b/include/xrpl/ledger/helpers/LendingHelpers.h
index 9008c528a5..6e1299687b 100644
--- a/include/xrpl/ledger/helpers/LendingHelpers.h
+++ b/include/xrpl/ledger/helpers/LendingHelpers.h
@@ -304,7 +304,7 @@ loanOriginationDeltas(Number const& principalRequested, Number const& interestDu
 
 // LoanManage impair/unimpair/default: the vault's exposure to this loan
 Number
-loanVaultExposure(SLE::ref loanSle);
+loanVaultExposure(SLE::const_ref loanSle);
 
 // LoanPay: what's added to Vault.AssetsTotal and subtracted from LoanBroker.DebtTotal for a payment
 AccountingDeltas
@@ -317,10 +317,10 @@ loanPaymentDeltas(LoanPaymentParts const& parts);
 namespace CashBasis {
 
 AccountingDeltas
-loanOriginationDeltas(Number const& principalRequested, Number const& interestDue);
+loanOriginationDeltas(Number const& principalRequested);
 
 Number
-loanVaultExposure(SLE::ref loanSle);
+loanVaultExposure(SLE::const_ref loanSle);
 
 AccountingDeltas
 loanPaymentDeltas(LoanPaymentParts const& parts);
@@ -328,18 +328,21 @@ loanPaymentDeltas(LoanPaymentParts const& parts);
 }  // namespace CashBasis
 
 // Public dispatchers: pick CashBasis:: if featureLendingProtocolV1_1 is
-// enabled, else Accrual::. These are the only entry points transactors call.
+// enabled AND the Vault's LEVersion (VaultHelpers::getVaultVersion) is
+// VaultVersion::CashBasis, else Accrual::. These are the only entry points
+// transactors call.
 AccountingDeltas
 loanOriginationDeltas(
     Rules const& rules,
+    SLE::const_ref vaultSle,
     Number const& principalRequested,
     Number const& interestDue);
 
 Number
-loanVaultExposure(Rules const& rules, SLE::ref loanSle);
+loanVaultExposure(Rules const& rules, SLE::const_ref vaultSle, SLE::const_ref loanSle);
 
 AccountingDeltas
-loanPaymentDeltas(Rules const& rules, LoanPaymentParts const& parts);
+loanPaymentDeltas(Rules const& rules, SLE::const_ref vaultSle, LoanPaymentParts const& parts);
 
 namespace detail {
 // These classes and functions should only be accessed by LendingHelper
diff --git a/include/xrpl/ledger/helpers/VaultHelpers.h b/include/xrpl/ledger/helpers/VaultHelpers.h
index 1bd1663314..e0101bd742 100644
--- a/include/xrpl/ledger/helpers/VaultHelpers.h
+++ b/include/xrpl/ledger/helpers/VaultHelpers.h
@@ -2,6 +2,7 @@
 
 #include <xrpl/ledger/ReadView.h>
 #include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Protocol.h>
 #include <xrpl/protocol/STAmount.h>
 #include <xrpl/protocol/STLedgerEntry.h>
 
@@ -107,4 +108,17 @@ sharesToAssetsWithdraw(
 [[nodiscard]] bool
 isSoleShareholder(ReadView const& view, AccountID const& account, SLE::const_ref issuance);
 
+/**
+ * Resolves a Vault's LEVersion, the single point every accounting touch
+ * point should call to determine which recognition model (accrual vs.
+ * cash-basis) a Vault uses. Vaults created before featureLendingProtocolV1_1
+ * activated never have sfLEVersion set, which resolves here to 0 (legacy).
+ *
+ * @param vault The vault SLE.
+ *
+ * @return The Vault's LEVersion, or 0 if the field is absent.
+ */
+[[nodiscard]] VaultVersion
+getVaultVersion(SLE::const_ref vault);
+
 }  // namespace xrpl
diff --git a/include/xrpl/protocol/Protocol.h b/include/xrpl/protocol/Protocol.h
index e83e1c97b6..f387ea56de 100644
--- a/include/xrpl/protocol/Protocol.h
+++ b/include/xrpl/protocol/Protocol.h
@@ -316,6 +316,18 @@ constexpr std::uint8_t kVaultDefaultIouScale = 6;
  */
 constexpr std::uint8_t kVaultMaximumIouScale = 18;
 
+/**
+ * Vault ledger-entry schema versions. Assigned to newly created
+ * Vaults once featureLendingProtocolV1_1 is enabled. Vaults created before
+ * activation are left without LEVersion (implicit legacy version 0,
+ * accrual-basis accounting).
+ */
+enum class VaultVersion : uint8_t {
+    Legacy = 0,
+    Invalid,
+    CashBasis,
+};
+
 /**
  * Maximum recursion depth for vault shares being put as an asset inside
  * another vault; counted from 0
diff --git a/include/xrpl/protocol/detail/ledger_entries.macro b/include/xrpl/protocol/detail/ledger_entries.macro
index 90810e06d2..b6408581a9 100644
--- a/include/xrpl/protocol/detail/ledger_entries.macro
+++ b/include/xrpl/protocol/detail/ledger_entries.macro
@@ -505,6 +505,7 @@ LEDGER_ENTRY(ltVAULT, 0x0084, Vault, vault, ({
     {sfShareMPTID,           SoeRequired},
     {sfWithdrawalPolicy,     SoeRequired},
     {sfScale,                SoeDefault},
+    {sfLEVersion,            SoeDefault},
     // no SharesTotal ever (use MPTIssuance.sfOutstandingAmount)
     // no PermissionedDomainID ever (use MPTIssuance.sfDomainID)
 }))
diff --git a/include/xrpl/protocol/detail/sfields.macro b/include/xrpl/protocol/detail/sfields.macro
index 4ef76c8b75..16defe3ba3 100644
--- a/include/xrpl/protocol/detail/sfields.macro
+++ b/include/xrpl/protocol/detail/sfields.macro
@@ -18,6 +18,7 @@ TYPED_SFIELD(sfMethod,                   UINT8,      2)
 TYPED_SFIELD(sfTransactionResult,        UINT8,      3)
 TYPED_SFIELD(sfScale,                    UINT8,      4)
 TYPED_SFIELD(sfAssetScale,               UINT8,      5)
+TYPED_SFIELD(sfLEVersion,                UINT8,      6)
 
 // 8-bit integers (uncommon)
 TYPED_SFIELD(sfTickSize,                 UINT8,     16)
diff --git a/src/libxrpl/ledger/helpers/LendingHelpers.cpp b/src/libxrpl/ledger/helpers/LendingHelpers.cpp
index 1bc8e3bfe4..988c9cbcc1 100644
--- a/src/libxrpl/ledger/helpers/LendingHelpers.cpp
+++ b/src/libxrpl/ledger/helpers/LendingHelpers.cpp
@@ -9,6 +9,7 @@
 #include <xrpl/ledger/ApplyView.h>
 #include <xrpl/ledger/ReadView.h>
 #include <xrpl/ledger/View.h>
+#include <xrpl/ledger/helpers/VaultHelpers.h>
 #include <xrpl/protocol/Asset.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/LedgerFormats.h>
@@ -139,7 +140,7 @@ loanOriginationDeltas(Number const& principalRequested, Number const& interestDu
 }
 
 Number
-loanVaultExposure(SLE::ref loanSle)
+loanVaultExposure(SLE::const_ref loanSle)
 {
     return loanSle->at(sfTotalValueOutstanding) - loanSle->at(sfManagementFeeOutstanding);
 }
@@ -157,13 +158,13 @@ loanPaymentDeltas(LoanPaymentParts const& parts)
 namespace CashBasis {
 
 AccountingDeltas
-loanOriginationDeltas(Number const& principalRequested, Number const&)
+loanOriginationDeltas(Number const& principalRequested)
 {
     return {.assetsTotalDelta = kNumZero, .debtTotalDelta = principalRequested};
 }
 
 Number
-loanVaultExposure(SLE::ref loanSle)
+loanVaultExposure(SLE::const_ref loanSle)
 {
     return loanSle->at(sfPrincipalOutstanding);
 }
@@ -176,29 +177,45 @@ loanPaymentDeltas(LoanPaymentParts const& parts)
 
 }  // namespace CashBasis
 
+namespace {
+
+// Cash-basis accounting applies only when featureLendingProtocolV1_1 is
+// enabled AND the specific Vault was created under it (LEVersion ==
+// VaultVersion::CashBasis). Vaults created before activation keep accrual-basis
+// accounting forever, even after the amendment later turns on.
+bool
+cashBasisEnabled(Rules const& rules, SLE::const_ref vaultSle)
+{
+    return rules.enabled(featureLendingProtocolV1_1) &&
+        getVaultVersion(vaultSle) == VaultVersion::CashBasis;
+}
+
+}  // namespace
+
 AccountingDeltas
 loanOriginationDeltas(
     Rules const& rules,
+    SLE::const_ref vaultSle,
     Number const& principalRequested,
     Number const& interestDue)
 {
-    return rules.enabled(featureLendingProtocolV1_1)
-        ? CashBasis::loanOriginationDeltas(principalRequested, interestDue)
+    return cashBasisEnabled(rules, vaultSle)
+        ? CashBasis::loanOriginationDeltas(principalRequested)
         : Accrual::loanOriginationDeltas(principalRequested, interestDue);
 }
 
 Number
-loanVaultExposure(Rules const& rules, SLE::ref loanSle)
+loanVaultExposure(Rules const& rules, SLE::const_ref vaultSle, SLE::const_ref loanSle)
 {
-    return rules.enabled(featureLendingProtocolV1_1) ? CashBasis::loanVaultExposure(loanSle)
-                                                     : Accrual::loanVaultExposure(loanSle);
+    return cashBasisEnabled(rules, vaultSle) ? CashBasis::loanVaultExposure(loanSle)
+                                             : Accrual::loanVaultExposure(loanSle);
 }
 
 AccountingDeltas
-loanPaymentDeltas(Rules const& rules, LoanPaymentParts const& parts)
+loanPaymentDeltas(Rules const& rules, SLE::const_ref vaultSle, LoanPaymentParts const& parts)
 {
-    return rules.enabled(featureLendingProtocolV1_1) ? CashBasis::loanPaymentDeltas(parts)
-                                                     : Accrual::loanPaymentDeltas(parts);
+    return cashBasisEnabled(rules, vaultSle) ? CashBasis::loanPaymentDeltas(parts)
+                                             : Accrual::loanPaymentDeltas(parts);
 }
 
 namespace detail {
diff --git a/src/libxrpl/ledger/helpers/VaultHelpers.cpp b/src/libxrpl/ledger/helpers/VaultHelpers.cpp
index b5b076d1cb..5b2694250d 100644
--- a/src/libxrpl/ledger/helpers/VaultHelpers.cpp
+++ b/src/libxrpl/ledger/helpers/VaultHelpers.cpp
@@ -6,6 +6,7 @@
 #include <xrpl/protocol/AccountID.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/LedgerFormats.h>  // IWYU pragma: keep
+#include <xrpl/protocol/Protocol.h>
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/STAmount.h>
 #include <xrpl/protocol/STLedgerEntry.h>
@@ -137,4 +138,22 @@ isSoleShareholder(ReadView const& view, AccountID const& account, SLE::const_ref
     return sleToken->getFieldU64(sfMPTAmount) == outstanding;
 }
 
+[[nodiscard]] VaultVersion
+getVaultVersion(SLE::const_ref vault)
+{
+    XRPL_ASSERT(vault && vault->getType() == ltVAULT, "xrpl::getVaultVersion : valid Vault sle");
+    if (!vault->isFieldPresent(sfLEVersion))
+        return VaultVersion::Legacy;
+
+    switch (vault->at(sfLEVersion))
+    {
+        case 0:
+            return VaultVersion::Legacy;
+        case 2:
+            return VaultVersion::CashBasis;
+        default:
+            return VaultVersion::Invalid;
+    }
+}
+
 }  // namespace xrpl
diff --git a/src/libxrpl/tx/transactors/lending/LoanManage.cpp b/src/libxrpl/tx/transactors/lending/LoanManage.cpp
index 20f3b79ae5..5c71843129 100644
--- a/src/libxrpl/tx/transactors/lending/LoanManage.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanManage.cpp
@@ -141,7 +141,7 @@ LoanManage::defaultLoan(
     std::int32_t const loanScale = loanSle->at(sfLoanScale);
     auto brokerDebtTotalProxy = brokerSle->at(sfDebtTotal);
 
-    Number const totalDefaultAmount = loanVaultExposure(view.rules(), loanSle);
+    Number const totalDefaultAmount = loanVaultExposure(view.rules(), vaultSle, loanSle);
 
     // Apply the First-Loss Capital to the Default Amount
     TenthBips32 const coverRateMinimum{brokerSle->at(sfCoverRateMinimum)};
@@ -287,7 +287,7 @@ LoanManage::impairLoan(
     Asset const& vaultAsset,
     beast::Journal j)
 {
-    Number const lossUnrealized = loanVaultExposure(view.rules(), loanSle);
+    Number const lossUnrealized = loanVaultExposure(view.rules(), vaultSle, loanSle);
 
     // The vault may be at a different scale than the loan. Reduce rounding
     // errors during the accounting by rounding some of the values to that
@@ -336,7 +336,7 @@ LoanManage::unimpairLoan(
 
     // Update the Vault object(clear "paper loss")
     auto vaultLossUnrealizedProxy = vaultSle->at(sfLossUnrealized);
-    Number const lossReversed = loanVaultExposure(view.rules(), loanSle);
+    Number const lossReversed = loanVaultExposure(view.rules(), vaultSle, loanSle);
     if (vaultLossUnrealizedProxy < lossReversed)
     {
         // LCOV_EXCL_START
diff --git a/src/libxrpl/tx/transactors/lending/LoanPay.cpp b/src/libxrpl/tx/transactors/lending/LoanPay.cpp
index da35ebee42..6566a7155d 100644
--- a/src/libxrpl/tx/transactors/lending/LoanPay.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanPay.cpp
@@ -420,7 +420,8 @@ LoanPay::doApply()
         // LCOV_EXCL_STOP
     }
 
-    auto const [assetsTotalDelta, debtTotalDelta] = loanPaymentDeltas(view.rules(), *paymentParts);
+    auto const [assetsTotalDelta, debtTotalDelta] =
+        loanPaymentDeltas(view.rules(), vaultSle, *paymentParts);
 
     JLOG(j_.debug()) << "Loan Pay: principal paid: " << paymentParts->principalPaid
                      << ", interest paid: " << paymentParts->interestPaid
diff --git a/src/libxrpl/tx/transactors/lending/LoanSet.cpp b/src/libxrpl/tx/transactors/lending/LoanSet.cpp
index 34be342dd8..52d3361db7 100644
--- a/src/libxrpl/tx/transactors/lending/LoanSet.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanSet.cpp
@@ -634,7 +634,7 @@ LoanSet::doApply()
 
     // Update the balances in the vault
     auto const [assetsTotalDelta, debtTotalDelta] =
-        loanOriginationDeltas(ctx_.view().rules(), principalRequested, state.interestDue);
+        loanOriginationDeltas(ctx_.view().rules(), vaultSle, principalRequested, state.interestDue);
     vaultAvailableProxy -= principalRequested;
     vaultTotalProxy += assetsTotalDelta;
     XRPL_ASSERT_PARTS(
diff --git a/src/libxrpl/tx/transactors/vault/VaultCreate.cpp b/src/libxrpl/tx/transactors/vault/VaultCreate.cpp
index e1f5873a89..a522f62788 100644
--- a/src/libxrpl/tx/transactors/vault/VaultCreate.cpp
+++ b/src/libxrpl/tx/transactors/vault/VaultCreate.cpp
@@ -30,6 +30,7 @@
 #include <cstdint>
 #include <memory>
 #include <optional>
+#include <utility>
 
 namespace xrpl {
 
@@ -241,6 +242,8 @@ VaultCreate::doApply()
     }
     if (scale != 0u)
         vault->at(sfScale) = scale;
+    if (view().rules().enabled(featureLendingProtocolV1_1))
+        vault->at(sfLEVersion) = std::to_underlying(VaultVersion::CashBasis);
     view().insert(vault);
 
     // Explicitly create MPToken for the vault owner
diff --git a/src/test/app/LendingHelpers_test.cpp b/src/test/app/LendingHelpers_test.cpp
index af1c229495..b27c976646 100644
--- a/src/test/app/LendingHelpers_test.cpp
+++ b/src/test/app/LendingHelpers_test.cpp
@@ -9,6 +9,7 @@
 #include <xrpl/ledger/helpers/LendingHelpers.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/Protocol.h>
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/STAmount.h>
 #include <xrpl/protocol/STLedgerEntry.h>
@@ -19,6 +20,7 @@
 #include <memory>
 #include <optional>
 #include <string>
+#include <utility>
 #include <vector>
 
 namespace xrpl::test {
@@ -1518,7 +1520,7 @@ class LendingHelpers_test : public beast::unit_test::Suite
         Number const principalRequested{1'000};
         Number const interestDue{75};
 
-        auto const deltas = loanOriginationDeltas(principalRequested, interestDue);
+        auto const deltas = loanOriginationDeltas(principalRequested);
         BEAST_EXPECTS(
             deltas.assetsTotalDelta == 0,
             "assetsTotalDelta mismatch: expected 0, got " + to_string(deltas.assetsTotalDelta));
@@ -1544,6 +1546,17 @@ class LendingHelpers_test : public beast::unit_test::Suite
         return sle;
     }
 
+    // Constructs a minimal ltVAULT SLE with just LEVersion set (or left
+    // absent), for exercising the dispatchers' per-Vault gating.
+    static std::shared_ptr<SLE>
+    makeVaultSle(std::optional<VaultVersion> leVersion = std::nullopt)
+    {
+        auto sle = std::make_shared<SLE>(ltVAULT, uint256{2u});
+        if (leVersion)
+            sle->at(sfLEVersion) = std::to_underlying(*leVersion);
+        return sle;
+    }
+
     void
     testAccrualLoanVaultExposure()
     {
@@ -1599,12 +1612,15 @@ class LendingHelpers_test : public beast::unit_test::Suite
         Number const principalRequested{1'000};
         Number const interestDue{75};
 
+        auto const legacyVault = makeVaultSle();
+        auto const cashBasisVault = makeVaultSle(VaultVersion::CashBasis);
+
         {
             testcase("loanOriginationDeltas dispatcher: amendment disabled picks Accrual");
             Env env{*this};
             env.disableFeature(featureLendingProtocolV1_1);
-            auto const deltas =
-                loanOriginationDeltas(env.current()->rules(), principalRequested, interestDue);
+            auto const deltas = loanOriginationDeltas(
+                env.current()->rules(), cashBasisVault, principalRequested, interestDue);
             auto const expected =
                 xrpl::Accrual::loanOriginationDeltas(principalRequested, interestDue);
             BEAST_EXPECT(deltas.assetsTotalDelta == expected.assetsTotalDelta);
@@ -1612,12 +1628,26 @@ class LendingHelpers_test : public beast::unit_test::Suite
         }
 
         {
-            testcase("loanOriginationDeltas dispatcher: amendment enabled picks CashBasis");
+            testcase(
+                "loanOriginationDeltas dispatcher: amendment enabled, legacy vault picks "
+                "Accrual");
             Env const env{*this};
-            auto const deltas =
-                loanOriginationDeltas(env.current()->rules(), principalRequested, interestDue);
+            auto const deltas = loanOriginationDeltas(
+                env.current()->rules(), legacyVault, principalRequested, interestDue);
             auto const expected =
-                xrpl::CashBasis::loanOriginationDeltas(principalRequested, interestDue);
+                xrpl::Accrual::loanOriginationDeltas(principalRequested, interestDue);
+            BEAST_EXPECT(deltas.assetsTotalDelta == expected.assetsTotalDelta);
+            BEAST_EXPECT(deltas.debtTotalDelta == expected.debtTotalDelta);
+        }
+
+        {
+            testcase(
+                "loanOriginationDeltas dispatcher: amendment enabled, LEVersion == "
+                "VaultVersion::CashBasis picks CashBasis");
+            Env const env{*this};
+            auto const deltas = loanOriginationDeltas(
+                env.current()->rules(), cashBasisVault, principalRequested, interestDue);
+            auto const expected = xrpl::CashBasis::loanOriginationDeltas(principalRequested);
             BEAST_EXPECT(deltas.assetsTotalDelta == expected.assetsTotalDelta);
             BEAST_EXPECT(deltas.debtTotalDelta == expected.debtTotalDelta);
         }
@@ -1628,22 +1658,37 @@ class LendingHelpers_test : public beast::unit_test::Suite
     {
         using namespace jtx;
 
+        auto const legacyVault = makeVaultSle();
+        auto const cashBasisVault = makeVaultSle(VaultVersion::CashBasis);
+
         {
             testcase("loanVaultExposure dispatcher: amendment disabled picks Accrual");
             Env env{*this};
             env.disableFeature(featureLendingProtocolV1_1);
             auto sle = makeLoanSle(Number{1'000}, Number{800}, Number{50});
             BEAST_EXPECT(
-                loanVaultExposure(env.current()->rules(), sle) ==
+                loanVaultExposure(env.current()->rules(), cashBasisVault, sle) ==
                 xrpl::Accrual::loanVaultExposure(sle));
         }
 
         {
-            testcase("loanVaultExposure dispatcher: amendment enabled picks CashBasis");
+            testcase("loanVaultExposure dispatcher: amendment enabled, legacy vault picks Accrual");
             Env const env{*this};
             auto sle = makeLoanSle(Number{1'000}, Number{800}, Number{50});
             BEAST_EXPECT(
-                loanVaultExposure(env.current()->rules(), sle) ==
+                loanVaultExposure(env.current()->rules(), legacyVault, sle) ==
+                xrpl::Accrual::loanVaultExposure(sle));
+        }
+
+        {
+            testcase(
+                "loanVaultExposure dispatcher: amendment enabled, LEVersion == "
+                "VaultVersion::CashBasis "
+                "picks CashBasis");
+            Env const env{*this};
+            auto sle = makeLoanSle(Number{1'000}, Number{800}, Number{50});
+            BEAST_EXPECT(
+                loanVaultExposure(env.current()->rules(), cashBasisVault, sle) ==
                 xrpl::CashBasis::loanVaultExposure(sle));
         }
     }
@@ -1659,20 +1704,35 @@ class LendingHelpers_test : public beast::unit_test::Suite
             .valueChange = Number{5},
             .feePaid = Number{3}};
 
+        auto const legacyVault = makeVaultSle();
+        auto const cashBasisVault = makeVaultSle(VaultVersion::CashBasis);
+
         {
             testcase("loanPaymentDeltas dispatcher: amendment disabled picks Accrual");
             Env env{*this};
             env.disableFeature(featureLendingProtocolV1_1);
-            auto const deltas = loanPaymentDeltas(env.current()->rules(), parts);
+            auto const deltas = loanPaymentDeltas(env.current()->rules(), cashBasisVault, parts);
             auto const expected = xrpl::Accrual::loanPaymentDeltas(parts);
             BEAST_EXPECT(deltas.assetsTotalDelta == expected.assetsTotalDelta);
             BEAST_EXPECT(deltas.debtTotalDelta == expected.debtTotalDelta);
         }
 
         {
-            testcase("loanPaymentDeltas dispatcher: amendment enabled picks CashBasis");
+            testcase("loanPaymentDeltas dispatcher: amendment enabled, legacy vault picks Accrual");
             Env const env{*this};
-            auto const deltas = loanPaymentDeltas(env.current()->rules(), parts);
+            auto const deltas = loanPaymentDeltas(env.current()->rules(), legacyVault, parts);
+            auto const expected = xrpl::Accrual::loanPaymentDeltas(parts);
+            BEAST_EXPECT(deltas.assetsTotalDelta == expected.assetsTotalDelta);
+            BEAST_EXPECT(deltas.debtTotalDelta == expected.debtTotalDelta);
+        }
+
+        {
+            testcase(
+                "loanPaymentDeltas dispatcher: amendment enabled, LEVersion == "
+                "VaultVersion::CashBasis "
+                "picks CashBasis");
+            Env const env{*this};
+            auto const deltas = loanPaymentDeltas(env.current()->rules(), cashBasisVault, parts);
             auto const expected = xrpl::CashBasis::loanPaymentDeltas(parts);
             BEAST_EXPECT(deltas.assetsTotalDelta == expected.assetsTotalDelta);
             BEAST_EXPECT(deltas.debtTotalDelta == expected.debtTotalDelta);
diff --git a/src/test/app/Loan_test.cpp b/src/test/app/Loan_test.cpp
index 96ec716c7f..3d124b9dc4 100644
--- a/src/test/app/Loan_test.cpp
+++ b/src/test/app/Loan_test.cpp
@@ -39,6 +39,7 @@
 #include <xrpl/json/to_string.h>
 #include <xrpl/ledger/helpers/AccountRootHelpers.h>
 #include <xrpl/ledger/helpers/LendingHelpers.h>
+#include <xrpl/ledger/helpers/VaultHelpers.h>
 #include <xrpl/protocol/Asset.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/HashPrefix.h>
@@ -368,18 +369,21 @@ protected:
             {
                 TenthBips16 const managementFeeRate{brokerSle->at(sfManagementFeeRate)};
                 auto const brokerDebt = brokerSle->at(sfDebtTotal);
-                auto const expectedDebt = env.current()->rules().enabled(featureLendingProtocolV1_1)
-                    ? principalOutstanding
-                    : principalOutstanding + interestOwed;
-                env.test.BEAST_EXPECT(brokerDebt == expectedDebt);
-                env.test.BEAST_EXPECT(
-                    env.balance(pseudoAccount, broker.asset).number() ==
-                    brokerSle->at(sfCoverAvailable));
-                env.test.BEAST_EXPECT(brokerSle->at(sfOwnerCount) == ownerCount);
 
                 if (auto vaultSle = env.le(keylet::vault(brokerSle->at(sfVaultID)));
                     env.test.BEAST_EXPECT(vaultSle))
                 {
+                    auto const expectedDebt =
+                        env.current()->rules().enabled(featureLendingProtocolV1_1) &&
+                            getVaultVersion(vaultSle) == VaultVersion::CashBasis
+                        ? principalOutstanding
+                        : principalOutstanding + interestOwed;
+                    env.test.BEAST_EXPECT(brokerDebt == expectedDebt);
+                    env.test.BEAST_EXPECT(
+                        env.balance(pseudoAccount, broker.asset).number() ==
+                        brokerSle->at(sfCoverAvailable));
+                    env.test.BEAST_EXPECT(brokerSle->at(sfOwnerCount) == ownerCount);
+
                     Account const vaultPseudo{"vaultPseudoAccount", vaultSle->at(sfAccount)};
                     env.test.BEAST_EXPECT(
                         vaultSle->at(sfAssetsAvailable) ==
@@ -475,7 +479,8 @@ protected:
                         {
                             env.test.BEAST_EXPECT(
                                 vaultSle->at(sfLossUnrealized) ==
-                                (env.current()->rules().enabled(featureLendingProtocolV1_1)
+                                (env.current()->rules().enabled(featureLendingProtocolV1_1) &&
+                                         getVaultVersion(vaultSle) == VaultVersion::CashBasis
                                      ? principalOutstanding
                                      : totalValue - managementFeeOutstanding));
                         }
@@ -645,7 +650,8 @@ protected:
                 auto const assetsUnavailable =
                     vaultSle->at(sfAssetsTotal) - vaultSle->at(sfAssetsAvailable);
                 auto const unrealizedLoss = vaultSle->at(sfLossUnrealized) +
-                    (env.current()->rules().enabled(featureLendingProtocolV1_1)
+                    (env.current()->rules().enabled(featureLendingProtocolV1_1) &&
+                             getVaultVersion(vaultSle) == VaultVersion::CashBasis
                          ? state.principalOutstanding
                          : state.totalValue - state.managementFeeOutstanding);
 
@@ -9190,6 +9196,197 @@ protected:
         }
     }
 
+    // 3b. LEVersion regression: a Vault created before featureLendingProtocolV1_1
+    // activates (LEVersion absent) must keep whole-life (accrual) accounting
+    // forever, even after the amendment is later enabled -- the switch is
+    // per-Vault (LEVersion == VaultVersion::CashBasis), not a single global amendment
+    // flag.
+    void
+    testLegacyVaultKeepsAccrualAfterAmendmentEnabled()
+    {
+        testcase("LEVersion: legacy vault keeps accrual after amendment enabled");
+
+        using namespace jtx;
+        using namespace loan;
+        using namespace std::chrono_literals;
+
+        PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
+        BrokerParameters const brokerParams{
+            .vaultDeposit = 1'000'000,
+            .debtMax = 0,
+            .coverRateMin = TenthBips32{percentageToTenthBips(10)},
+            .coverDeposit = 5'000,
+            .managementFeeRate = TenthBips16{0},
+            .coverRateLiquidation = TenthBips32{percentageToTenthBips(25)}};
+
+        Number const principalRequest{10'000};
+        TenthBips32 const interestRate{percentageToTenthBips(12)};
+        std::uint32_t const paymentTotal = 4;
+        std::uint32_t const paymentInterval = 600;
+        std::uint32_t const gracePeriod = 60;
+
+        // Amendment disabled at Vault creation time: LEVersion stays absent.
+        Env env(*this, all_);
+
+        Account const lender{"lender"};
+        Account const borrower{"borrower"};
+        env.fund(XRP(10'000'000), lender, borrower);
+        env.close();
+
+        BrokerInfo const broker{createVaultAndBroker(env, xrpAsset, lender, brokerParams)};
+
+        {
+            auto const vaultSle = env.le(broker.vaultKeylet());
+            BEAST_EXPECT(vaultSle);
+            BEAST_EXPECT(!vaultSle->isFieldPresent(sfLEVersion));
+        }
+
+        // Now enable the amendment -- production dispatch must still treat
+        // this specific Vault as accrual-basis, since its LEVersion is
+        // (and remains) absent.
+        env.enableFeature(featureLendingProtocolV1_1);
+        env.close();
+
+        LoanParameters const loanParams{
+            .account = borrower,
+            .counter = lender,
+            .principalRequest = principalRequest,
+            .interest = interestRate,
+            .payTotal = paymentTotal,
+            .payInterval = paymentInterval,
+            .gracePd = gracePeriod,
+        };
+
+        auto const brokerBeforeLoan = env.le(broker.brokerKeylet());
+        BEAST_EXPECT(brokerBeforeLoan);
+        auto const loanSequence = brokerBeforeLoan->at(sfLoanSequence);
+        auto const loanKeylet = keylet::loan(broker.brokerID, loanSequence);
+
+        // ---- LoanSet origination: whole-life formulas expected ----
+        auto const vaultBeforeSet = env.le(broker.vaultKeylet());
+        auto const brokerBeforeSet = env.le(broker.brokerKeylet());
+        BEAST_EXPECT(vaultBeforeSet && brokerBeforeSet);
+        Number const assetsTotalBeforeSet = vaultBeforeSet->at(sfAssetsTotal);
+        Number const debtTotalBeforeSet = brokerBeforeSet->at(sfDebtTotal);
+
+        env(loanParams(env, broker));
+        env.close();
+
+        auto const loanAfterSet = env.le(loanKeylet);
+        BEAST_EXPECT(loanAfterSet);
+        Number const principalOutstanding = loanAfterSet->at(sfPrincipalOutstanding);
+        Number const totalValueOutstanding = loanAfterSet->at(sfTotalValueOutstanding);
+        Number const interestDue = totalValueOutstanding - principalOutstanding;
+        BEAST_EXPECT(interestDue > beast::kZero);
+
+        auto const vaultAfterSet = env.le(broker.vaultKeylet());
+        auto const brokerAfterSet = env.le(broker.brokerKeylet());
+        BEAST_EXPECT(vaultAfterSet && brokerAfterSet);
+        Number const assetsTotalDeltaSet =
+            Number(vaultAfterSet->at(sfAssetsTotal)) - assetsTotalBeforeSet;
+        Number const debtTotalDeltaSet =
+            Number(brokerAfterSet->at(sfDebtTotal)) - debtTotalBeforeSet;
+
+        BEAST_EXPECTS(
+            assetsTotalDeltaSet == interestDue,
+            "legacy vault origination must still add interestDue to AssetsTotal; delta=" +
+                to_string(assetsTotalDeltaSet) + " interestDue=" + to_string(interestDue));
+        BEAST_EXPECTS(
+            debtTotalDeltaSet == principalOutstanding + interestDue,
+            "legacy vault origination must still add principal+interest to DebtTotal; delta=" +
+                to_string(debtTotalDeltaSet));
+
+        LoanState const state = getCurrentState(env, broker, loanKeylet);
+        env.close();
+
+        // ---- LoanPay: whole-life formulas expected ----
+        auto const vaultBeforePay = env.le(broker.vaultKeylet());
+        auto const brokerBeforePay = env.le(broker.brokerKeylet());
+        auto const loanBeforePay = env.le(loanKeylet);
+        BEAST_EXPECT(vaultBeforePay && brokerBeforePay && loanBeforePay);
+        Number const totalValueBeforePay = loanBeforePay->at(sfTotalValueOutstanding);
+        Number const assetsTotalBeforePay = vaultBeforePay->at(sfAssetsTotal);
+        Number const debtTotalBeforePay = brokerBeforePay->at(sfDebtTotal);
+
+        STAmount const paymentAmount{
+            xrpAsset, roundPeriodicPayment(xrpAsset, state.periodicPayment, state.loanScale)};
+        env(pay(borrower, loanKeylet.key, paymentAmount), Ter(tesSUCCESS));
+        env.close();
+
+        auto const vaultAfterPay = env.le(broker.vaultKeylet());
+        auto const brokerAfterPay = env.le(broker.brokerKeylet());
+        auto const loanAfterPay = env.le(loanKeylet);
+        BEAST_EXPECT(vaultAfterPay && brokerAfterPay && loanAfterPay);
+        Number const totalValueAfterPay = loanAfterPay->at(sfTotalValueOutstanding);
+        Number const assetsTotalDeltaPay =
+            Number(vaultAfterPay->at(sfAssetsTotal)) - assetsTotalBeforePay;
+        Number const debtTotalDeltaPay =
+            Number(brokerAfterPay->at(sfDebtTotal)) - debtTotalBeforePay;
+        Number const totalValueDeltaPay = totalValueAfterPay - totalValueBeforePay;
+
+        // A regular, on-time payment has valueChange == 0, so whole-life
+        // AssetsTotal is untouched and DebtTotal mirrors TotalValueOutstanding.
+        BEAST_EXPECTS(
+            assetsTotalDeltaPay == beast::kZero,
+            "legacy vault regular payment must not change AssetsTotal; delta=" +
+                to_string(assetsTotalDeltaPay));
+        BEAST_EXPECTS(
+            debtTotalDeltaPay == totalValueDeltaPay,
+            "legacy vault DebtTotal delta must mirror TotalValueOutstanding delta; "
+            "debtTotalDelta=" +
+                to_string(debtTotalDeltaPay) + " totalValueDelta=" + to_string(totalValueDeltaPay));
+
+        // ---- LoanManage: impair, then default -- whole-life exposure expected ----
+        auto const loanBeforeImpair = env.le(loanKeylet);
+        BEAST_EXPECT(loanBeforeImpair);
+        Number const totalValueBeforeImpair = loanBeforeImpair->at(sfTotalValueOutstanding);
+        Number const managementFeeBeforeImpair = loanBeforeImpair->at(sfManagementFeeOutstanding);
+        Number const expectedExposure = totalValueBeforeImpair - managementFeeBeforeImpair;
+
+        env(manage(lender, loanKeylet.key, tfLoanImpair), Ter(tesSUCCESS));
+        env.close();
+
+        LoanState const stateAtImpair = getCurrentState(env, broker, loanKeylet);
+        env.close(
+            stateAtImpair.startDate + std::chrono::seconds(paymentInterval) +
+            std::chrono::seconds(gracePeriod) + 60s);
+
+        auto const vaultBeforeDefault = env.le(broker.vaultKeylet());
+        auto const brokerBeforeDefault = env.le(broker.brokerKeylet());
+        BEAST_EXPECT(vaultBeforeDefault && brokerBeforeDefault);
+        Number const debtTotalBeforeDefault = brokerBeforeDefault->at(sfDebtTotal);
+        Number const lossBeforeDefault = vaultBeforeDefault->at(sfLossUnrealized);
+
+        env(manage(lender, loanKeylet.key, tfLoanDefault), Ter(tesSUCCESS));
+        env.close();
+
+        auto const vaultAfterDefault = env.le(broker.vaultKeylet());
+        auto const brokerAfterDefault = env.le(broker.brokerKeylet());
+        BEAST_EXPECT(vaultAfterDefault && brokerAfterDefault);
+        Number const debtTotalDeltaDefault =
+            Number(brokerAfterDefault->at(sfDebtTotal)) - debtTotalBeforeDefault;
+        Number const lossDeltaDefault =
+            Number(vaultAfterDefault->at(sfLossUnrealized)) - lossBeforeDefault;
+
+        BEAST_EXPECTS(
+            debtTotalDeltaDefault == -expectedExposure,
+            "legacy vault default must reduce DebtTotal by whole-life exposure; delta=" +
+                to_string(debtTotalDeltaDefault) + " expected=" + to_string(expectedExposure));
+        BEAST_EXPECTS(
+            lossDeltaDefault == -expectedExposure,
+            "legacy vault default must reverse the earlier impair's LossUnrealized exactly; "
+            "delta=" +
+                to_string(lossDeltaDefault) + " expected=" + to_string(expectedExposure));
+
+        // Confirm the Vault's LEVersion truly never got set, throughout.
+        {
+            auto const vaultSle = env.le(broker.vaultKeylet());
+            BEAST_EXPECT(vaultSle);
+            BEAST_EXPECT(!vaultSle->isFieldPresent(sfLEVersion));
+            BEAST_EXPECT(getVaultVersion(vaultSle) == VaultVersion::Legacy);
+        }
+    }
+
     // 4. End-to-end trajectory: LoanSet -> 2 LoanPays -> LoanManage(default),
     // entirely under the amendment, with independently hand-computed
     // expected AssetsTotal/DebtTotal/LossUnrealized/CoverAvailable values at
@@ -9351,6 +9548,7 @@ protected:
         testCashBasisLoanSetOrigination();
         testCashBasisLoanPay();
         testCashBasisLoanManage();
+        testLegacyVaultKeepsAccrualAfterAmendmentEnabled();
         testCashBasisEndToEndTrajectory();
     }
 
diff --git a/src/test/app/Vault_test.cpp b/src/test/app/Vault_test.cpp
index 617820c89c..0fbfd1a52f 100644
--- a/src/test/app/Vault_test.cpp
+++ b/src/test/app/Vault_test.cpp
@@ -7646,6 +7646,81 @@ class Vault_test : public beast::unit_test::Suite
         }
     }
 
+    void
+    testVaultCreateLEVersion()
+    {
+        using namespace test::jtx;
+
+        Account const owner{"owner"};
+        PrettyAsset const xrpAsset = xrpIssue();
+
+        {
+            testcase("VaultCreate LEVersion: featureLendingProtocolV1_1 disabled, field absent");
+            Env env{*this};
+            env.disableFeature(featureLendingProtocolV1_1);
+            env.fund(XRP(1'000'000), owner);
+            env.close();
+
+            Vault const vault{env};
+            auto const [tx, keylet] = vault.create({.owner = owner, .asset = xrpAsset});
+            env(tx, Ter(tesSUCCESS));
+            env.close();
+
+            auto const sleVault = env.le(keylet);
+            BEAST_EXPECT(sleVault);
+            BEAST_EXPECT(!sleVault->isFieldPresent(sfLEVersion));
+        }
+
+        {
+            testcase("VaultCreate LEVersion: featureLendingProtocolV1_1 enabled, LEVersion == 2");
+            Env env{*this};
+            env.fund(XRP(1'000'000), owner);
+            env.close();
+
+            Vault const vault{env};
+            auto const [tx, keylet] = vault.create({.owner = owner, .asset = xrpAsset});
+            env(tx, Ter(tesSUCCESS));
+            env.close();
+
+            auto const sleVault = env.le(keylet);
+            BEAST_EXPECT(sleVault);
+            BEAST_EXPECT(sleVault->isFieldPresent(sfLEVersion));
+            BEAST_EXPECT(sleVault->at(sfLEVersion) == std::to_underlying(VaultVersion::CashBasis));
+        }
+
+        {
+            testcase("VaultCreate rejects LEVersion set in the transaction");
+            Env env{*this};
+            env.fund(XRP(1'000'000), owner);
+            env.close();
+
+            Vault const vault{env};
+            auto [tx, keylet] = vault.create({.owner = owner, .asset = xrpAsset});
+            tx[sfLEVersion] = 2;
+            env(tx, Ter(temMALFORMED));
+            env.close();
+
+            BEAST_EXPECT(!env.le(keylet));
+        }
+
+        {
+            testcase("VaultSet rejects LEVersion set in the transaction");
+            Env env{*this};
+            env.fund(XRP(1'000'000), owner);
+            env.close();
+
+            Vault const vault{env};
+            auto const [createTx, keylet] = vault.create({.owner = owner, .asset = xrpAsset});
+            env(createTx, Ter(tesSUCCESS));
+            env.close();
+
+            auto setTx = vault.set({.owner = owner, .id = keylet.key});
+            setTx[sfLEVersion] = 2;
+            env(setTx, Ter(temMALFORMED));
+            env.close();
+        }
+    }
+
     void
     testVaultDepositFreezeIOU()
     {
@@ -8318,6 +8393,7 @@ public:
         testVaultEscrowedMPT();
         testAssetsMaximum();
         testVaultDeleteMemoData();
+        testVaultCreateLEVersion();
         testBug6LimitBypassWithShares();
         testRemoveEmptyHoldingLockedAmount();
         testRemoveEmptyHoldingConfidentialBalances();