diff --git a/LICENSE.TXT b/LICENSE.TXT
index 8daec70da1..66b86c78a6 100644
--- a/LICENSE.TXT
+++ b/LICENSE.TXT
@@ -171,6 +171,8 @@ QuantLib is
     Copyright (C) 2024 Jacques du Toit
     Copyright (C) 2024 Jongbong An
 
+    Copyright (C) 2025 Paolo D'Elia
+
 QuantLib includes code taken from Peter Jäckel's book "Monte Carlo
 Methods in Finance".
 
diff --git a/ql/cashflows/overnightindexedcouponpricer.cpp b/ql/cashflows/overnightindexedcouponpricer.cpp
index 81f98b775f..1b5a2779d8 100644
--- a/ql/cashflows/overnightindexedcouponpricer.cpp
+++ b/ql/cashflows/overnightindexedcouponpricer.cpp
@@ -40,6 +40,16 @@ namespace QuantLib {
             // always one less than the number of interest dates.
             return n == interestDates.size() && applyObservationShift ? n - 1 : n;
         }
+
+        void updateCompoundFactor(Real& compoundFactor, const ext::shared_ptr<OvernightIndex> index, Size position, 
+            const std::vector<Date>& fixingDates, const std::vector<Date>& interestDates, const std::vector<Time>& dt,
+            const Date& date) {
+            const Rate fixing = index->fixing(fixingDates[position]);
+            Time span = (date >= interestDates[position + 1] ?
+                dt[position] :
+                index->dayCounter().yearFraction(interestDates[position], date));
+            compoundFactor *= (1.0 + fixing * span);
+        }
     }
 
     void CompoundingOvernightIndexedCouponPricer::initialize(const FloatingRateCoupon& coupon) {
@@ -51,47 +61,47 @@ namespace QuantLib {
         return averageRate(coupon_->accrualEndDate());
     }
 
-    Rate CompoundingOvernightIndexedCouponPricer::averageRate(const Date& date) const {
-        const Date today = Settings::instance().evaluationDate();
-
-        const ext::shared_ptr<OvernightIndex> index =
-            ext::dynamic_pointer_cast<OvernightIndex>(coupon_->index());
-        const auto& pastFixings = index->timeSeries();
-
-        const auto& fixingDates = coupon_->fixingDates();
-        const auto& valueDates = coupon_->valueDates();
-        const auto& interestDates = coupon_->interestDates();
-        const auto& dt = coupon_->dt();
-        const bool applyObservationShift = coupon_->applyObservationShift();
-
-        Size i = 0;
-        const Size n = determineNumberOfFixings(interestDates, date, applyObservationShift);
-
-        Real compoundFactor = 1.0;
-
-        // already fixed part
-        while (i < n && fixingDates[i] < today) {
-            // rate must have been fixed
-            const Rate fixing = pastFixings[fixingDates[i]];
-            QL_REQUIRE(fixing != Null<Real>(),
-                       "Missing " << index->name() << " fixing for " << fixingDates[i]);
-            Time span = (date >= interestDates[i + 1] ?
-                             dt[i] :
-                             index->dayCounter().yearFraction(interestDates[i], date));
-            compoundFactor *= (1.0 + fixing * span);
-            ++i;
+    void CompoundingOvernightIndexedCouponPricer::handlePastFixings(Size& i, const Size n, Real& compoundFactor, 
+        const ext::shared_ptr<OvernightIndex> index, const Dates& fixingDates, 
+        const Dates& valueDates, const Dates& interestDates, const Times& dt, 
+        const Date& today, const Date& date, const bool applyObservationShift) const {
+        Calendar fixingCalendar = index->fixingCalendar();
+        Size deltaDays = fixingCalendar.businessDaysBetween(fixingDates[0], today);
+        Date lastPastFixingDate = n < deltaDays
+            ? fixingCalendar.advance(fixingDates[0], Period(n, Days)) : fixingCalendar.advance(today, Period(-1, Days));
+        Real indexCompoundedFactor = index->compoundedFactor(fixingDates[0], lastPastFixingDate);
+
+        auto calculatePastCompoundFactor = [&](){
+            while (i < n && fixingDates[i] < today) {
+                // rate must have been fixed
+                updateCompoundFactor(compoundFactor, index, i, fixingDates, interestDates, dt, date);
+                ++i;
+            }
+        };
+
+        if (indexCompoundedFactor == Null<Real>() 
+            || applyObservationShift 
+            || coupon_->lockoutDays() != Null<Natural>()) {
+            calculatePastCompoundFactor();
+        } else {
+            compoundFactor = indexCompoundedFactor;
+            i = fixingCalendar.businessDaysBetween(fixingDates[0], 
+                                                   lastPastFixingDate,
+                                                   true, true);
         }
+    }
 
+    void CompoundingOvernightIndexedCouponPricer::handleTodayFixing(Size& i, 
+        Size n, Real& compoundFactor, const ext::shared_ptr<OvernightIndex> index, 
+        const Dates& fixingDates, const Dates& interestDates, const Times& dt, 
+        const Date& today, const Date& date) const {
         // today is a border case
         if (i < n && fixingDates[i] == today) {
             // might have been fixed
             try {
-                Rate fixing = pastFixings[fixingDates[i]];
+                Rate fixing = index->fixing(fixingDates[i]);
                 if (fixing != Null<Real>()) {
-                    Time span = (date >= interestDates[i + 1] ?
-                                     dt[i] :
-                                     index->dayCounter().yearFraction(interestDates[i], date));
-                    compoundFactor *= (1.0 + fixing * span);
+                    updateCompoundFactor(compoundFactor, index, i, fixingDates, interestDates, dt, date);
                     ++i;
                 } else {
                     ; // fall through and forecast
@@ -100,7 +110,13 @@ namespace QuantLib {
                 ; // fall through and forecast
             }
         }
+    }
 
+    void CompoundingOvernightIndexedCouponPricer::handleFutureFixings(Size& i, Size n, 
+        Real& compoundFactor, const ext::shared_ptr<OvernightIndex> index,
+        const Dates& valueDates, const Dates& fixingDates, 
+        const Dates& interestDates, const Times& dt, const Date& today, 
+        const Date& date) const {
         // forward part using telescopic property in order
         // to avoid the evaluation of multiple forward fixings
         // where possible.
@@ -109,15 +125,6 @@ namespace QuantLib {
             QL_REQUIRE(!curve.empty(),
                        "null term structure set to this instance of " << index->name());
 
-            const auto effectiveRate = [&index, &fixingDates, &date, &interestDates,
-                                        &dt](Size position) {
-                Rate fixing = index->fixing(fixingDates[position]);
-                Time span = (date >= interestDates[position + 1] ?
-                                 dt[position] :
-                                 index->dayCounter().yearFraction(interestDates[position], date));
-                return span * fixing;
-            };
-
             if (!coupon_->canApplyTelescopicFormula()) {
                 // With lookback applied, the telescopic formula cannot be used,
                 // we need to project each fixing in the coupon.
@@ -130,7 +137,7 @@ namespace QuantLib {
                 // Same applies to a case when accrual calculation date does or
                 // does not occur on an interest date.
                 while (i < n) {
-                    compoundFactor *= (1.0 + effectiveRate(i));
+                    updateCompoundFactor(compoundFactor, index, i, fixingDates, interestDates, dt, date);
                     ++i;
                 }
             } else {
@@ -157,7 +164,7 @@ namespace QuantLib {
 
                     // With no lockout, the loop is skipped because i = n.
                     while (i < n) {
-                        compoundFactor *= (1.0 + effectiveRate(i));
+                        updateCompoundFactor(compoundFactor, index, i, fixingDates, interestDates, dt, date);
                         ++i;
                     }
                 } else {
@@ -167,10 +174,36 @@ namespace QuantLib {
                     // previous date, then we'll add the missing bit.
                     const DiscountFactor endDiscount = curve->discount(valueDates[n - 1]);
                     compoundFactor *= startDiscount / endDiscount;
-                    compoundFactor *= (1.0 + effectiveRate(n - 1));
+                    updateCompoundFactor(compoundFactor, index, n - 1, fixingDates, interestDates, dt, date);
                 }
             }
         }
+    }
+
+    Rate CompoundingOvernightIndexedCouponPricer::averageRate(const Date& date) const {
+        const Date today = Settings::instance().evaluationDate();
+
+        const ext::shared_ptr<OvernightIndex> index =
+            ext::dynamic_pointer_cast<OvernightIndex>(coupon_->index());
+
+        const auto& fixingDates = coupon_->fixingDates();
+        const auto& valueDates = coupon_->valueDates();
+        const auto& interestDates = coupon_->interestDates();
+        const auto& dt = coupon_->dt();
+        const bool applyObservationShift = coupon_->applyObservationShift();
+
+        Size i = 0;
+        const Size n = determineNumberOfFixings(interestDates, date, applyObservationShift);
+        Real compoundFactor = 1.0;
+
+        handlePastFixings(i, n, compoundFactor, index, fixingDates, valueDates, 
+                          interestDates, dt, today, date, applyObservationShift);
+
+        handleTodayFixing(i, n, compoundFactor, index, fixingDates, interestDates,
+                          dt, today, date);
+
+        handleFutureFixings(i, n, compoundFactor, index, valueDates, fixingDates,
+                            interestDates, dt, today, date);
 
         const Rate rate = (compoundFactor - 1.0) / coupon_->accruedPeriod(date);
         return coupon_->gearing() * rate + coupon_->spread();
diff --git a/ql/cashflows/overnightindexedcouponpricer.hpp b/ql/cashflows/overnightindexedcouponpricer.hpp
index 984af3cf2a..07d42a6596 100644
--- a/ql/cashflows/overnightindexedcouponpricer.hpp
+++ b/ql/cashflows/overnightindexedcouponpricer.hpp
@@ -37,6 +37,8 @@ namespace QuantLib {
 
     //! CompoudAveragedOvernightIndexedCouponPricer pricer
     class CompoundingOvernightIndexedCouponPricer : public FloatingRateCouponPricer {
+      using Dates = std::vector<Date>;
+      using Times = std::vector<Time>;
       public:
         //! \name FloatingRateCoupon interface
         //@{
@@ -52,6 +54,19 @@ namespace QuantLib {
 
       protected:
         const OvernightIndexedCoupon* coupon_ = nullptr;
+
+      private:
+        void handlePastFixings(Size& i, const Size n, Real& compoundFactor, const ext::shared_ptr<OvernightIndex> index, 
+                               const Dates& fixingDates, const Dates& valueDates, const Dates& interestDates,
+                               const Times& dt, const Date& today, const Date& date, const bool applyObservationShift) const;
+        void handleTodayFixing(Size& i, Size n, Real& compoundFactor, 
+          const ext::shared_ptr<OvernightIndex> index, const Dates& fixingDates,
+          const Dates& interestDates, const Times& dt, const Date& today, 
+          const Date& date) const;
+        void handleFutureFixings(Size& i, Size n, Real& compoundFactor,
+          const ext::shared_ptr<OvernightIndex> index, const Dates& fixingDates,
+          const Dates& valueDates, const Dates& interestDates, const Times& dt, 
+          const Date& today, const Date& date) const;
     };
 
     /*! pricer for arithmetically averaged overnight indexed coupons
diff --git a/ql/index.hpp b/ql/index.hpp
index b7da8d98b9..cb690d6083 100644
--- a/ql/index.hpp
+++ b/ql/index.hpp
@@ -42,7 +42,7 @@ namespace QuantLib {
                  possible inconsistencies due to "seeing in the
                  future"
     */
-    class Index : public Observable, public Observer {
+    class Index : virtual public Observable, virtual public Observer {
       public:
         ~Index() override = default;
         //! Returns the name of the index.
@@ -91,7 +91,7 @@ namespace QuantLib {
         /*! the dates in the TimeSeries must be the actual calendar
             dates of the fixings; no settlement days must be used.
         */
-        void addFixings(const TimeSeries<Real>& t, bool forceOverwrite = false);
+        virtual void addFixings(const TimeSeries<Real>& t, bool forceOverwrite = false);
         //! stores historical fixings at the given dates
         /*! the dates passed as arguments must be the actual calendar
             dates of the fixings; no settlement days must be used.
diff --git a/ql/indexes/iborindex.cpp b/ql/indexes/iborindex.cpp
index eafdf405ac..6ed8e14d65 100644
--- a/ql/indexes/iborindex.cpp
+++ b/ql/indexes/iborindex.cpp
@@ -21,6 +21,7 @@
 
 #include <ql/indexes/iborindex.hpp>
 #include <ql/termstructures/yieldtermstructure.hpp>
+#include <ql/time/schedule.hpp>
 #include <utility>
 
 namespace QuantLib {
@@ -60,16 +61,15 @@ namespace QuantLib {
 
     ext::shared_ptr<IborIndex> IborIndex::clone(
                                const Handle<YieldTermStructure>& h) const {
-        return ext::make_shared<IborIndex>(
-                                        familyName(),
-                                                      tenor(),
-                                                      fixingDays(),
-                                                      currency(),
-                                                      fixingCalendar(),
-                                                      businessDayConvention(),
-                                                      endOfMonth(),
-                                                      dayCounter(),
-                                                      h);
+        return ext::make_shared<IborIndex>(familyName(),
+                                           tenor(),
+                                           fixingDays(),
+                                           currency(),
+                                           fixingCalendar(),
+                                           businessDayConvention(),
+                                           endOfMonth(),
+                                           dayCounter(),
+                                           h);
     }
 
 
@@ -82,6 +82,84 @@ namespace QuantLib {
    : IborIndex(familyName, 1*Days, settlementDays, curr,
                fixCal, Following, false, dc, h) {}
 
+    void OvernightIndex::addFixing(const Date& fixingDate, Real fixing, bool forceOverwrite) {
+        calculated_ = false;
+        Index::addFixing(fixingDate, fixing, forceOverwrite);
+    }
+
+    void OvernightIndex::addFixings(const TimeSeries<Real>& t, bool forceOverwrite) {
+        calculated_ = false;
+        Index::addFixings(t, forceOverwrite);
+    }
+
+    Rate OvernightIndex::compoundedFixings(const Date& fromFixingDate, const Date& toFixingDate) {
+        calculate();
+        auto yearFraction = dayCounter_.yearFraction(fromFixingDate, toFixingDate);
+        auto compIndexEnd = compoundIndex_[toFixingDate];
+        auto compIndexStart = compoundIndex_[fromFixingDate];
+
+        if (compIndexStart == Null<Real>() || compIndexEnd == Null<Real>())
+            return Null<Real>();
+
+        return (compoundIndex_[toFixingDate] / compoundIndex_[fromFixingDate] - 1) / yearFraction;  
+    }
+
+    Real OvernightIndex::compoundedFactor(const Date& fromFixingDate, const Date& toFixingDate) {
+        calculate();
+        auto compIndexEnd = compoundIndex_[toFixingDate];
+        auto compIndexStart = compoundIndex_[fromFixingDate];
+
+        if (compIndexStart == Null<Real>() || compIndexEnd == Null<Real>())
+            return Null<Real>();
+
+        return compIndexEnd / compIndexStart;
+    }
+ 
+    void OvernightIndex::performCalculations() const {
+        auto getLastFixingDate = [](Calendar fixingCalendar, std::vector<Date>& fixingDates){
+            Date lastFixingDay = fixingDates.front();
+            std::for_each(fixingDates.begin() + 1, fixingDates.end(), [&](Date& fixingDate){
+                if (fixingCalendar.advance(lastFixingDay, Period(1, Days)) == fixingDate)
+                    lastFixingDay = fixingDate;
+            });
+            return lastFixingDay;
+        };
+
+        const auto& ts = Index::timeSeries();
+        auto fixingDates = ts.dates();
+        if (fixingDates.empty()) {
+            compoundIndex_ = TimeSeries<Real>();
+            return;
+        }
+
+        auto fixingCalendar = InterestRateIndex::fixingCalendar();
+        auto lastFixingDate = getLastFixingDate(fixingCalendar, fixingDates);
+        Schedule schedule = MakeSchedule()
+                                .from(fixingDates.front())
+                                .to(lastFixingDate)
+                                .withTenor(Period(1, Days))
+                                .withCalendar(fixingCalendar)
+                                .withConvention(Following)
+                                .withTerminationDateConvention(Following);
+        std::vector<Real> compIndexValues(schedule.size());
+        Real lastCompIndexValue = 1.000;
+        compIndexValues[0] = lastCompIndexValue;
+
+        std::transform(schedule.begin(), schedule.end() - 1, schedule.begin() + 1, compIndexValues.begin() + 1,
+            [&](const Date& d1, const Date& d2) {
+                lastCompIndexValue *= (1 + ts[d1] * dayCounter_.yearFraction(d1, d2));
+                return lastCompIndexValue;
+            });
+
+        compoundIndex_ = TimeSeries<Real>(schedule.begin(), 
+                                          schedule.end(), 
+                                          compIndexValues.begin());
+    }
+
+    void OvernightIndex::update() {
+        notifyObservers();
+    }
+
     ext::shared_ptr<IborIndex> OvernightIndex::clone(
                                const Handle<YieldTermStructure>& h) const {
         return ext::shared_ptr<IborIndex>(
diff --git a/ql/indexes/iborindex.hpp b/ql/indexes/iborindex.hpp
index 790c8b3126..b1606a2206 100644
--- a/ql/indexes/iborindex.hpp
+++ b/ql/indexes/iborindex.hpp
@@ -28,6 +28,7 @@
 
 #include <ql/indexes/interestrateindex.hpp>
 #include <ql/termstructures/yieldtermstructure.hpp>
+#include <ql/patterns/lazyobject.hpp>
 
 namespace QuantLib {
 
@@ -85,8 +86,20 @@ namespace QuantLib {
     };
 
 
-    class OvernightIndex : public IborIndex {
+    /*! Base class for overnight indexes, (e.g. %SOFR, %ESTR, etc.)
+    */
+    class OvernightIndex : public IborIndex,
+                           virtual public LazyObject {
       public:
+        //! Constructor for the OvernightIndex
+        /*!
+            \param familyName The name of the index family (e.g., "ESTR").
+            \param settlementDays The number of settlement days for the index.
+            \param currency The currency of the index.
+            \param fixingCalendar The calendar used for fixing dates.
+            \param dayCounter The day count convention for the index.
+            \param h The yield term structure used for forecasting fixings (optional).
+        */
         OvernightIndex(const std::string& familyName,
                        Natural settlementDays,
                        const Currency& currency,
@@ -95,6 +108,44 @@ namespace QuantLib {
                        const Handle<YieldTermStructure>& h = {});
         //! returns a copy of itself linked to a different forwarding curve
         ext::shared_ptr<IborIndex> clone(const Handle<YieldTermStructure>& h) const override;
+        //! \name Observer interface
+        //@{
+        void update() override;
+        //@}
+        //! stores the historical fixing at the given date
+        /*! the date passed as arguments must be the actual calendar
+            date of the fixing; no settlement days must be used.
+        */
+        void addFixing(const Date& fixingDate, Real fixing, bool forceOverwrite = false) override;
+        //! stores historical fixings from a TimeSeries
+        /*! the dates in the TimeSeries must be the actual calendar
+            dates of the fixings; no settlement days must be used.
+        */
+        void addFixings(const TimeSeries<Real>& t, bool forceOverwrite = false) override;
+        //! Computes the compounded fixings over a given date range
+        /*!
+            This method calculates the compounded rate for the index over the specified
+            date range, using historical fixings stored in the index's time series.
+
+            \param fromFixingDate The start date of the fixing period.
+            \param toFixingDate The end date of the fixing period.
+            \return The compounded rate over the specified date range, or `Null<Rate>()` if any fixings are missing.
+        */
+        Rate compoundedFixings(const Date& fromFixingDate, const Date& toFixingDate);
+        //! Computes the compounded factor over a given date range
+        /*!
+            This method calculates the compounded factor for the index over the specified
+            date range, using historical fixings stored in the index's time series.
+
+            \param fromFixingDate The start date of the fixing period.
+            \param toFixingDate The end date of the fixing period.
+            \return The compounded factor over the specified date range, or `Null<Real>()` if any fixings are missing.
+        */
+        Real compoundedFactor(const Date& fromFixingDate, const Date& toFixingDate);
+      protected:
+          void performCalculations() const override;
+      private:
+        mutable TimeSeries<Real> compoundIndex_;
     };
 
 
diff --git a/test-suite/CMakeLists.txt b/test-suite/CMakeLists.txt
index 39ab5081e4..a30a9d3826 100644
--- a/test-suite/CMakeLists.txt
+++ b/test-suite/CMakeLists.txt
@@ -119,6 +119,7 @@ set(QL_TEST_SOURCES
     operators.cpp
     optimizers.cpp
     optionletstripper.cpp
+    overnightindex.cpp
     overnightindexedcoupon.cpp
     overnightindexedswap.cpp
     pagodaoption.cpp
diff --git a/test-suite/Makefile.am b/test-suite/Makefile.am
index c881f4f388..b6215f2e5a 100644
--- a/test-suite/Makefile.am
+++ b/test-suite/Makefile.am
@@ -120,6 +120,7 @@ QL_TEST_SRCS = \
 	operators.cpp \
 	optimizers.cpp \
 	optionletstripper.cpp \
+	overnightindex.cpp \
 	overnightindexedcoupon.cpp \
 	overnightindexedswap.cpp \
 	pagodaoption.cpp \
diff --git a/test-suite/libormarketmodel.cpp b/test-suite/libormarketmodel.cpp
index 38e659e2d8..296fc19590 100644
--- a/test-suite/libormarketmodel.cpp
+++ b/test-suite/libormarketmodel.cpp
@@ -58,7 +58,7 @@ ext::shared_ptr<IborIndex> makeIndex(std::vector<Date> dates, const std::vector<
 
     RelinkableHandle<YieldTermStructure> termStructure;
 
-    ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+    ext::shared_ptr<IborIndex> index = ext::make_shared<Euribor6M>(termStructure);
 
     Date todaysDate =
         index->fixingCalendar().adjust(Date(4,September,2005));
diff --git a/test-suite/overnightindex.cpp b/test-suite/overnightindex.cpp
new file mode 100644
index 0000000000..bf0772abd0
--- /dev/null
+++ b/test-suite/overnightindex.cpp
@@ -0,0 +1,194 @@
+/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*
+ Copyright (C) 2025 Paolo D'Elia
+
+ This file is part of QuantLib, a free-software/open-source library
+ for financial quantitative analysts and developers - http://quantlib.org/
+
+ QuantLib is free software: you can redistribute it and/or modify it
+ under the terms of the QuantLib license.  You should have received a
+ copy of the license along with this program; if not, please email
+ <quantlib-dev@lists.sf.net>. The license is also available online at
+ <http://quantlib.org/license.shtml>.
+
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE.  See the license for more details.
+*/
+#include "toplevelfixture.hpp"
+#include "utilities.hpp"
+#include <ql/indexes/iborindex.hpp>
+#include <ql/indexes/ibor/estr.hpp>
+#include <ql/settings.hpp>
+#include <ql/time/calendars/all.hpp>
+#include <ql/time/daycounters/actual360.hpp>
+#include <ql/termstructures/yield/flatforward.hpp>
+#include <ql/quotes/simplequote.hpp>
+#include <iomanip>
+
+using namespace QuantLib;
+using namespace boost::unit_test_framework;
+
+BOOST_FIXTURE_TEST_SUITE(QuantLibTests, TopLevelFixture)
+
+BOOST_AUTO_TEST_SUITE(OvernightIndexTest)
+
+struct CommonVars {
+    Date today;
+    ext::shared_ptr<OvernightIndex> estr;
+    RelinkableHandle<YieldTermStructure> forecastCurve;
+
+    CommonVars(const Date& evaluationDate) {
+        today = evaluationDate;
+
+        Settings::instance().evaluationDate() = today;
+
+        estr = ext::make_shared<Estr>(forecastCurve);
+
+        
+        std::vector<Date> pastDates = {
+            Date(14, February, 2025), Date(17, February, 2025), Date(18, February, 2025), Date(19, February, 2025), Date(20, February, 2025),
+            Date(21, February, 2025), Date(24, February, 2025), Date(25, February, 2025), Date(26, February, 2025), Date(27, February, 2025),
+            Date(28, February, 2025), Date(3, March, 2025),     Date(4, March, 2025),     Date(5, March, 2025),     Date(6, March, 2025),
+            Date(7, March, 2025),     Date(10, March, 2025),    Date(11, March, 2025),    Date(12, March, 2025),    Date(13, March, 2025),
+            Date(14, March, 2025),    Date(17, March, 2025),    Date(18, March, 2025),    Date(19, March, 2025),    Date(20, March, 2025),
+            Date(21, March, 2025),    Date(24, March, 2025),    Date(25, March, 2025),    Date(26, March, 2025),    Date(27, March, 2025),
+            Date(28, March, 2025),    Date(31, March, 2025),    Date(1, April, 2025),     Date(2, April, 2025),     Date(3, April, 2025),
+            Date(4, April, 2025),     Date(7, April, 2025),     Date(8, April, 2025),     Date(9, April, 2025),     Date(10, April, 2025),
+            Date(11, April, 2025),    Date(14, April, 2025),    Date(15, April, 2025),    Date(16, April, 2025),    Date(17, April, 2025)
+        };
+
+        std::vector<Rate> pastRates = {
+            0.02666, 0.02665, 0.02666, 0.02665, 0.02667,
+            0.02666, 0.02666, 0.02666, 0.02665, 0.02666,
+            0.02658, 0.02663, 0.02664, 0.02664, 0.02666,
+            0.02665, 0.02663, 0.02663, 0.02412, 0.02413,
+            0.02417, 0.02417, 0.02417, 0.02416, 0.02417,
+            0.02417, 0.02418, 0.02418, 0.02417, 0.02417,
+            0.02417, 0.02415, 0.02420, 0.02417, 0.02416,
+            0.02415, 0.02414, 0.02415, 0.02415, 0.02416,
+            0.02416, 0.02417, 0.02416, 0.02418, 0.02417
+        };
+
+        TimeSeries<Real> ts(pastDates.begin(), pastDates.end(), pastRates.begin());
+        estr->addFixings(ts);
+    }
+
+    CommonVars() : CommonVars(Date(23, November, 2021)) {}
+};
+
+#define CHECK_OIS_RATE_RESULT(what, calculated, expected, tolerance)   \
+    if (std::fabs(calculated-expected) > tolerance) { \
+        BOOST_ERROR("Failed to reproduce " what ":" \
+                    << "\n    expected:   " << std::setprecision(12) << expected \
+                    << "\n    calculated: " << std::setprecision(12) << calculated \
+                    << "\n    error:      " << std::setprecision(12) << std::fabs(calculated-expected)); \
+    }
+
+
+BOOST_AUTO_TEST_CASE(testCompoundedIndex1m) {
+    BOOST_TEST_MESSAGE("Testing 1m rate for past overnight-indexed coupon...");
+
+    CommonVars vars;
+    Date today(22, April, 2025);
+    Settings::instance().evaluationDate() = today;
+
+    Calendar calendar = TARGET();
+    DayCounter dayCounter = Actual360();
+
+    Date fromFixingDate(14, February, 2025);
+    Date toFixingDate(14, March, 2025);
+
+    Rate compoundedRate = vars.estr->compoundedFixings(fromFixingDate, toFixingDate);
+
+    Rate expectedRate = 0.026489361171;
+
+    CHECK_OIS_RATE_RESULT("OIS Rate over a month", compoundedRate, expectedRate, 1e-12);
+}
+
+BOOST_AUTO_TEST_CASE(testCompoundedIndex2m) {
+    BOOST_TEST_MESSAGE("Testing 2m rate for past overnight-indexed coupon...");
+
+    CommonVars vars;
+    Date today(22, April, 2025);
+    Settings::instance().evaluationDate() = today;
+
+    Calendar calendar = TARGET();
+    DayCounter dayCounter = Actual360();
+
+    Date fromFixingDate(14, February, 2025);
+    Date toFixingDate(14, April, 2025);
+
+    Rate compoundedRate = vars.estr->compoundedFixings(fromFixingDate, toFixingDate);
+
+    Rate expectedRate = 0.02530656552467557;
+
+    CHECK_OIS_RATE_RESULT("OIS Rate over two months: ", compoundedRate, expectedRate, 1e-12);
+}
+
+BOOST_AUTO_TEST_CASE(testCompoundedIndexOutOfRangeBefore) {
+    BOOST_TEST_MESSAGE("Testing compounded fixings for a date range partially before available fixings...");
+
+    CommonVars vars;
+    Date today(22, April, 2025);
+    Settings::instance().evaluationDate() = today;
+
+    Calendar calendar = TARGET();
+    DayCounter dayCounter = Actual360();
+
+    Date fromFixingDate(11, February, 2025);
+    Date toFixingDate(11, March, 2025);
+
+    Rate compoundedRate = vars.estr->compoundedFixings(fromFixingDate, toFixingDate);
+
+    // Expected Null<Rate>
+    Rate expectedRate = Null<Rate>();
+
+    CHECK_OIS_RATE_RESULT("OIS Rate over a month", compoundedRate, expectedRate, 1e-12);
+}
+
+BOOST_AUTO_TEST_CASE(testCompoundedIndexOutOfRangeAfter) {
+    BOOST_TEST_MESSAGE("Testing compounded fixings for a date range partially after available fixings...");
+
+    CommonVars vars;
+    Date today(22, April, 2025);
+    Settings::instance().evaluationDate() = today;
+
+    Calendar calendar = TARGET();
+    DayCounter dayCounter = Actual360();
+
+    Date fromFixingDate(22, March, 2025);
+    Date toFixingDate(22, April, 2025);
+
+    Rate compoundedRate = vars.estr->compoundedFixings(fromFixingDate, toFixingDate);
+
+    // Expected Null<Rate>
+    Rate expectedRate = Null<Rate>();
+
+    CHECK_OIS_RATE_RESULT("OIS Rate over a month", compoundedRate, expectedRate, 1e-12);
+}
+
+BOOST_AUTO_TEST_CASE(testCompoundedFactor) {
+    BOOST_TEST_MESSAGE("Testing compoundFactor at the end of available fixings...");
+
+    CommonVars vars;
+    Date today(22, April, 2025);
+    Settings::instance().evaluationDate() = today;
+
+    Calendar calendar = TARGET();
+    DayCounter dayCounter = Actual360();
+
+    Date fromFixingDate(14, February, 2025);
+    Date toFixingDate(17, March, 2025);
+
+    Real compoundedFactor = vars.estr->compoundedFactor(fromFixingDate, toFixingDate);
+
+    Real expectedCompounedFactor = 1.002262115288;
+
+    CHECK_OIS_RATE_RESULT("OIS Rate over a month", compoundedFactor, expectedCompounedFactor, 1e-12);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file
diff --git a/test-suite/overnightindexedcoupon.cpp b/test-suite/overnightindexedcoupon.cpp
index 6ca1265149..28b8adcc80 100644
--- a/test-suite/overnightindexedcoupon.cpp
+++ b/test-suite/overnightindexedcoupon.cpp
@@ -104,7 +104,8 @@ struct CommonVars {
             0.0009
         };
 
-        sofr->addFixings(pastDates.begin(), pastDates.end(), pastRates.begin());
+        TimeSeries<Real> ts(pastDates.begin(), pastDates.end(), pastRates.begin());
+        sofr->addFixings(ts);
     }
 
     CommonVars() : CommonVars(Date(23, November, 2021)) {}
@@ -135,6 +136,21 @@ BOOST_AUTO_TEST_CASE(testPastCouponRate) {
     CHECK_OIS_COUPON_RESULT("coupon amount", pastCoupon->amount(), expectedAmount, 1e-8);
 }
 
+BOOST_AUTO_TEST_CASE(testPastCouponRateThroughIndex) {
+    BOOST_TEST_MESSAGE("Testing rate for past overnight-indexed coupon through compundFactor in index...");
+
+    CommonVars vars;
+
+    // coupon entirely in the past
+    auto pastCoupon = vars.makeCoupon(Date(1, July, 2019),
+                                      Date(1, August, 2019));
+
+    Rate expectedRate = 0.024537253424;
+    Real expectedAmount = vars.notional * expectedRate * 31.0/360;
+    CHECK_OIS_COUPON_RESULT("coupon rate", pastCoupon->rate(), expectedRate, 1e-12);
+    CHECK_OIS_COUPON_RESULT("coupon amount", pastCoupon->amount(), expectedAmount, 1e-8);
+}
+
 BOOST_AUTO_TEST_CASE(testCurrentCouponRate) {
     BOOST_TEST_MESSAGE("Testing rate for current overnight-indexed coupon...");
 
diff --git a/test-suite/testsuite.vcxproj b/test-suite/testsuite.vcxproj
index 01b8968066..1c57c7cfa8 100644
--- a/test-suite/testsuite.vcxproj
+++ b/test-suite/testsuite.vcxproj
@@ -764,6 +764,7 @@
     <ClCompile Include="operators.cpp" />
     <ClCompile Include="optimizers.cpp" />
     <ClCompile Include="optionletstripper.cpp" />
+    <ClCompile Include="overnightindex.cpp" />
     <ClCompile Include="overnightindexedcoupon.cpp" />
     <ClCompile Include="overnightindexedswap.cpp" />
     <ClCompile Include="pagodaoption.cpp" />
diff --git a/test-suite/testsuite.vcxproj.filters b/test-suite/testsuite.vcxproj.filters
index 0befa6b4de..d12ff38144 100644
--- a/test-suite/testsuite.vcxproj.filters
+++ b/test-suite/testsuite.vcxproj.filters
@@ -311,6 +311,9 @@
     <ClCompile Include="optionletstripper.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="overnightindex.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
     <ClCompile Include="overnightindexedcoupon.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>