diff --git a/QuantLib.vcxproj b/QuantLib.vcxproj
index a0bbb274750..c9e69684b9d 100644
--- a/QuantLib.vcxproj
+++ b/QuantLib.vcxproj
@@ -534,6 +534,7 @@
     <ClInclude Include="ql\cashflows\inflationcouponpricer.hpp" />
     <ClInclude Include="ql\cashflows\lineartsrpricer.hpp" />
     <ClInclude Include="ql\cashflows\overnightindexedcoupon.hpp" />
+    <ClInclude Include="ql\cashflows\overnightindexedcouponpricer.hpp" />
     <ClInclude Include="ql\cashflows\rangeaccrual.hpp" />
     <ClInclude Include="ql\cashflows\rateaveraging.hpp" />
     <ClInclude Include="ql\cashflows\replication.hpp" />
@@ -1933,6 +1934,7 @@
     <ClCompile Include="ql\cashflows\inflationcouponpricer.cpp" />
     <ClCompile Include="ql\cashflows\lineartsrpricer.cpp" />
     <ClCompile Include="ql\cashflows\overnightindexedcoupon.cpp" />
+    <ClCompile Include="ql\cashflows\overnightindexedcouponpricer.cpp" />
     <ClCompile Include="ql\cashflows\rangeaccrual.cpp" />
     <ClCompile Include="ql\cashflows\replication.cpp" />
     <ClCompile Include="ql\cashflows\simplecashflow.cpp" />
@@ -1951,7 +1953,6 @@
     <ClCompile Include="ql\experimental\asian\analytic_discr_geom_av_price_heston.cpp" />
     <ClCompile Include="ql\experimental\averageois\arithmeticaverageois.cpp" />
     <ClCompile Include="ql\experimental\averageois\arithmeticoisratehelper.cpp" />
-    <ClCompile Include="ql\experimental\averageois\averageoiscouponpricer.cpp" />
     <ClCompile Include="ql\experimental\averageois\makearithmeticaverageois.cpp" />
     <ClCompile Include="ql\experimental\barrieroption\discretizeddoublebarrieroption.cpp" />
     <ClCompile Include="ql\experimental\barrieroption\mcdoublebarrierengine.cpp" />
diff --git a/QuantLib.vcxproj.filters b/QuantLib.vcxproj.filters
index 8b09bc52e18..001b00b67ee 100644
--- a/QuantLib.vcxproj.filters
+++ b/QuantLib.vcxproj.filters
@@ -561,6 +561,9 @@
     <ClInclude Include="ql\cashflows\overnightindexedcoupon.hpp">
       <Filter>cashflows</Filter>
     </ClInclude>
+    <ClInclude Include="ql\cashflows\overnightindexedcouponpricer.hpp">
+      <Filter>cashflows</Filter>
+    </ClInclude>
     <ClInclude Include="ql\cashflows\rangeaccrual.hpp">
       <Filter>cashflows</Filter>
     </ClInclude>
@@ -4544,6 +4547,9 @@
     <ClCompile Include="ql\cashflows\overnightindexedcoupon.cpp">
       <Filter>cashflows</Filter>
     </ClCompile>
+    <ClCompile Include="ql\cashflows\overnightindexedcouponpricer.cpp">
+      <Filter>cashflows</Filter>
+    </ClCompile>
     <ClCompile Include="ql\cashflows\rangeaccrual.cpp">
       <Filter>cashflows</Filter>
     </ClCompile>
@@ -6590,9 +6596,6 @@
     <ClCompile Include="ql\experimental\averageois\arithmeticaverageois.cpp">
       <Filter>experimental\averageois</Filter>
     </ClCompile>
-    <ClCompile Include="ql\experimental\averageois\averageoiscouponpricer.cpp">
-      <Filter>experimental\averageois</Filter>
-    </ClCompile>
     <ClCompile Include="ql\experimental\averageois\arithmeticoisratehelper.cpp">
       <Filter>experimental\averageois</Filter>
     </ClCompile>
diff --git a/ql/CMakeLists.txt b/ql/CMakeLists.txt
index e000e1c276c..ca7950156d0 100644
--- a/ql/CMakeLists.txt
+++ b/ql/CMakeLists.txt
@@ -25,6 +25,7 @@ set(QL_SOURCES
     cashflows/inflationcouponpricer.cpp
     cashflows/lineartsrpricer.cpp
     cashflows/overnightindexedcoupon.cpp
+    cashflows/overnightindexedcouponpricer.cpp
     cashflows/rangeaccrual.cpp
     cashflows/replication.cpp
     cashflows/simplecashflow.cpp
@@ -49,7 +50,6 @@ set(QL_SOURCES
     experimental/asian/analytic_discr_geom_av_price_heston.cpp
     experimental/averageois/arithmeticaverageois.cpp
     experimental/averageois/arithmeticoisratehelper.cpp
-    experimental/averageois/averageoiscouponpricer.cpp
     experimental/averageois/makearithmeticaverageois.cpp
     experimental/barrieroption/mcdoublebarrierengine.cpp
     experimental/barrieroption/discretizeddoublebarrieroption.cpp
@@ -961,6 +961,7 @@ set(QL_HEADERS
     cashflows/inflationcouponpricer.hpp
     cashflows/lineartsrpricer.hpp
     cashflows/overnightindexedcoupon.hpp
+    cashflows/overnightindexedcouponpricer.hpp
     cashflows/rangeaccrual.hpp
     cashflows/rateaveraging.hpp
     cashflows/replication.hpp
diff --git a/ql/cashflows/Makefile.am b/ql/cashflows/Makefile.am
index 5320f812c93..f45d7c0274b 100644
--- a/ql/cashflows/Makefile.am
+++ b/ql/cashflows/Makefile.am
@@ -29,6 +29,7 @@ this_include_HEADERS = \
     inflationcouponpricer.hpp \
     lineartsrpricer.hpp \
     overnightindexedcoupon.hpp \
+    overnightindexedcouponpricer.hpp \
     rangeaccrual.hpp \
     rateaveraging.hpp \
     replication.hpp \
@@ -64,6 +65,7 @@ cpp_files = \
     inflationcouponpricer.cpp \
     lineartsrpricer.cpp \
     overnightindexedcoupon.cpp \
+    overnightindexedcouponpricer.cpp \
     rangeaccrual.cpp \
     replication.cpp \
     simplecashflow.cpp \
diff --git a/ql/cashflows/all.hpp b/ql/cashflows/all.hpp
index 59ee0ab2e11..ef579427e71 100644
--- a/ql/cashflows/all.hpp
+++ b/ql/cashflows/all.hpp
@@ -26,6 +26,7 @@
 #include <ql/cashflows/inflationcouponpricer.hpp>
 #include <ql/cashflows/lineartsrpricer.hpp>
 #include <ql/cashflows/overnightindexedcoupon.hpp>
+#include <ql/cashflows/overnightindexedcouponpricer.hpp>
 #include <ql/cashflows/rangeaccrual.hpp>
 #include <ql/cashflows/rateaveraging.hpp>
 #include <ql/cashflows/replication.hpp>
diff --git a/ql/cashflows/overnightindexedcoupon.cpp b/ql/cashflows/overnightindexedcoupon.cpp
index db1e8019d4c..0382671ad1d 100644
--- a/ql/cashflows/overnightindexedcoupon.cpp
+++ b/ql/cashflows/overnightindexedcoupon.cpp
@@ -22,7 +22,7 @@
 */
 
 #include <ql/cashflows/couponpricer.hpp>
-#include <ql/experimental/averageois/averageoiscouponpricer.hpp>
+#include <ql/cashflows/overnightindexedcouponpricer.hpp>
 #include <ql/cashflows/overnightindexedcoupon.hpp>
 #include <ql/termstructures/yieldtermstructure.hpp>
 #include <ql/utilities/vectors.hpp>
@@ -34,169 +34,6 @@ using std::vector;
 namespace QuantLib {
 
     namespace {
-
-        Size determineNumberOfFixings(const vector<Date>& interestDates,
-                                      const Date& date,
-                                      bool applyObservationShift) {
-            Size n =
-                std::lower_bound(interestDates.begin(), interestDates.end(), date) - interestDates.begin();
-            // When using the observation shift, it may happen that
-            // that the end of accrual period will fall later than the last
-            // interest date. In which case, n will be equal to the number of
-            // interest dates, while we know that the number of fixing dates is
-            // always one less than the number of interest dates.
-            return n == interestDates.size() && applyObservationShift ? n - 1 : n;
-        }
-
-        class OvernightIndexedCouponPricer : public FloatingRateCouponPricer {
-          public:
-            void initialize(const FloatingRateCoupon& coupon) override {
-                coupon_ = dynamic_cast<const OvernightIndexedCoupon*>(&coupon);
-                QL_ENSURE(coupon_, "wrong coupon type");
-            }
-
-            Rate 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 = IndexManager::instance().getHistory(index->name());
-
-                const vector<Date>& fixingDates = coupon_->fixingDates();
-                const vector<Date>& valueDates = coupon_->valueDates();
-                const vector<Date>& interestDates = coupon_->interestDates();
-                const vector<Time>& 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;
-                }
-
-                // today is a border case
-                if (i < n && fixingDates[i] == today) {
-                    // might have been fixed
-                    try {
-                        Rate fixing = pastFixings[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);
-                            ++i;
-                        } else {
-                            ;   // fall through and forecast
-                        }
-                    } catch (Error&) {
-                        ;       // fall through and forecast
-                    }
-                }
-
-                // forward part using telescopic property in order
-                // to avoid the evaluation of multiple forward fixings
-                // where possible.
-                if (i < n) {
-                    const Handle<YieldTermStructure> curve = index->forwardingTermStructure();
-                    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.
-                        // Only in one particular case when observation shift is used and
-                        // no intrinsic index fixing delay is applied, the telescopic formula
-                        // holds, because regardless of the fixing delay in the coupon,
-                        // in such configuration value dates will be equal to interest dates.
-                        // A potential lockout, which may occur in tandem with a lookback
-                        // setting, will be handled automatically based on fixing dates.
-                        // 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));
-                            ++i;
-                        }
-                    } else {
-                        // No lookback, we can partially apply the telescopic formula.
-                        // But we need to make a correction for a potential lockout.
-                        const Size nLockout = n - coupon_->lockoutDays();
-                        const bool isLockoutApplied = coupon_->lockoutDays() > 0;
-
-                        // Lockout could already start at or before i.
-                        // In such case the ratio of discount factors will be equal to 1.
-                        const DiscountFactor startDiscount =
-                            curve->discount(valueDates[std::min<Size>(nLockout, i)]);
-                        if (interestDates[n] == date || isLockoutApplied) {
-                            // telescopic formula up to potential lockout dates.
-                            const DiscountFactor endDiscount =
-                                curve->discount(valueDates[std::min<Size>(nLockout, n)]);
-                            compoundFactor *= startDiscount / endDiscount;
-                            // For the lockout periods the telescopic formula does not apply.
-                            // The value dates (at which the projection is calculated) correspond
-                            // to the locked-out fixing, while the interest dates (at which the
-                            // interest over that fixing is accrued) are not fixed at lockout,
-                            // hence they do not cancel out.
-                            i = std::max(nLockout, i);
-                            
-                            // With no lockout, the loop is skipped because i = n.
-                            while (i < n) {
-                                compoundFactor *= (1.0 + effectiveRate(i));
-                                ++i;
-                            }
-                        } else {
-                            // No lockout and date is different than last interest date.
-                            // The last fixing is not used for its full period (the date is between
-                            // its start and end date).  We can use the telescopic formula until the
-                            // 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));
-                        }
-                    }
-                }
-
-                const Rate rate = (compoundFactor - 1.0) / coupon_->accruedPeriod(date);
-                return coupon_->gearing() * rate + coupon_->spread();
-            }
-
-            Rate swapletRate() const override {
-                return averageRate(coupon_->accrualEndDate());
-            }
-
-            Real swapletPrice() const override { QL_FAIL("swapletPrice not available"); }
-            Real capletPrice(Rate) const override { QL_FAIL("capletPrice not available"); }
-            Rate capletRate(Rate) const override { QL_FAIL("capletRate not available"); }
-            Real floorletPrice(Rate) const override { QL_FAIL("floorletPrice not available"); }
-            Rate floorletRate(Rate) const override { QL_FAIL("floorletRate not available"); }
-
-          protected:
-            const OvernightIndexedCoupon* coupon_;
-        };
-
         Date applyLookbackPeriod(const ext::shared_ptr<InterestRateIndex>& index,
                                  const Date& valueDate,
                                  Natural lookbackDays) {
@@ -310,14 +147,14 @@ namespace QuantLib {
                     // If fixing dates of the coupon deviate from fixing days in the index
                     // we need to correct the value dates such that they reflect dates
                     // corresponding to a deposit instrument linked to the index.
-                    // This is to ensure that future projections (which are computed 
+                    // This is to ensure that future projections (which are computed
                     // based on the value dates) of the index do not
-                    // yield any convexity corrections. 
+                    // yield any convexity corrections.
                     valueDates_[i] = overnightIndex->valueDate(tmp);
             }
         }
-        // When lockout is used the fixing rate applied for the last k days of the 
-        // interest period is frozen at the rate observed k days before the period ends. 
+        // When lockout is used the fixing rate applied for the last k days of the
+        // interest period is frozen at the rate observed k days before the period ends.
         if (lockoutDays_ != 0) {
             QL_REQUIRE(lockoutDays_ > 0 && lockoutDays_ < n_,
                        "Lockout period cannot be negative or exceed the number of fixing days.");
@@ -333,21 +170,17 @@ namespace QuantLib {
             dt_[i] = dc.yearFraction(interestDates_[i], interestDates_[i + 1]);
 
         switch (averagingMethod) {
-            case RateAveraging::Simple:
-                QL_REQUIRE(
-                    fixingDays_ == overnightIndex->fixingDays() && !applyObservationShift_ &&
-                        lockoutDays_ == 0,
-                    "Cannot price an overnight coupon with simple averaging with lookback or "
-                    "lockout.");
-                setPricer(ext::shared_ptr<FloatingRateCouponPricer>(
-                    new ArithmeticAveragedOvernightIndexedCouponPricer(telescopicValueDates)));
-                break;
-            case RateAveraging::Compound:
-                setPricer(
-                    ext::shared_ptr<FloatingRateCouponPricer>(new OvernightIndexedCouponPricer));
-                break;
-            default:
-                QL_FAIL("unknown compounding convention (" << Integer(averagingMethod) << ")");
+          case RateAveraging::Simple:
+            QL_REQUIRE(
+                fixingDays_ == overnightIndex->fixingDays() && !applyObservationShift_ && lockoutDays_ == 0,
+                "Cannot price an overnight coupon with simple averaging with lookback or lockout.");
+            setPricer(ext::make_shared<ArithmeticAveragedOvernightIndexedCouponPricer>(telescopicValueDates));
+            break;
+          case RateAveraging::Compound:
+            setPricer(ext::make_shared<CompoundingOvernightIndexedCouponPricer>());
+            break;
+          default:
+            QL_FAIL("unknown compounding convention (" << Integer(averagingMethod) << ")");
         }
     }
 
@@ -366,10 +199,10 @@ namespace QuantLib {
     Rate OvernightIndexedCoupon::averageRate(const Date& d) const {
         QL_REQUIRE(pricer_, "pricer not set");
         pricer_->initialize(*this);
-        const auto overnightIndexPricer = ext::dynamic_pointer_cast<OvernightIndexedCouponPricer>(pricer_);
-        if (overnightIndexPricer)
-            return overnightIndexPricer->averageRate(d);
-
+        if (const auto compoundingPricer =
+                ext::dynamic_pointer_cast<CompoundingOvernightIndexedCouponPricer>(pricer_)) {
+            return compoundingPricer->averageRate(d);
+        }
         return pricer_->swapletRate();
     }
 
@@ -493,21 +326,13 @@ namespace QuantLib {
                 refEnd = calendar.adjust(start + schedule_.tenor(),
                                          paymentAdjustment_);
 
-            cashflows.push_back(ext::shared_ptr<CashFlow>(new
-                OvernightIndexedCoupon(paymentDate,
-                                       detail::get(notionals_, i,
-                                                   notionals_.back()),
-                                       start, end,
-                                       overnightIndex_,
-                                       detail::get(gearings_, i, 1.0),
-                                       detail::get(spreads_, i, 0.0),
-                                       refStart, refEnd,
-                                       paymentDayCounter_,
-                                       telescopicValueDates_,
-                                       averagingMethod_,
-                                       lookbackDays_,
-                                       lockoutDays_,
-                                       applyObservationShift_)));
+            const auto overnightIndexedCoupon = ext::make_shared<OvernightIndexedCoupon>(
+                paymentDate, detail::get(notionals_, i, notionals_.back()), start, end,
+                overnightIndex_, detail::get(gearings_, i, 1.0), detail::get(spreads_, i, 0.0),
+                refStart, refEnd, paymentDayCounter_, telescopicValueDates_, averagingMethod_,
+                lookbackDays_, lockoutDays_, applyObservationShift_);
+
+            cashflows.push_back(overnightIndexedCoupon);
         }
         return cashflows;
     }
diff --git a/ql/cashflows/overnightindexedcoupon.hpp b/ql/cashflows/overnightindexedcoupon.hpp
index 69a4ad5d5cc..3adb50262d1 100644
--- a/ql/cashflows/overnightindexedcoupon.hpp
+++ b/ql/cashflows/overnightindexedcoupon.hpp
@@ -28,6 +28,7 @@
 #ifndef quantlib_overnight_indexed_coupon_hpp
 #define quantlib_overnight_indexed_coupon_hpp
 
+#include <ql/cashflows/couponpricer.hpp>
 #include <ql/cashflows/floatingratecoupon.hpp>
 #include <ql/cashflows/rateaveraging.hpp>
 #include <ql/indexes/iborindex.hpp>
@@ -77,11 +78,11 @@ namespace QuantLib {
         //! interest dates for the rates to be compounded
         const std::vector<Date>& interestDates() const { return interestDates_; }
         //! averaging method
-        const RateAveraging::Type averagingMethod() const { return averagingMethod_; }
+        RateAveraging::Type averagingMethod() const { return averagingMethod_; }
         //! lockout days
-        const Natural lockoutDays() const { return lockoutDays_; }
+        Natural lockoutDays() const { return lockoutDays_; }
         //! apply observation shift
-        const bool applyObservationShift() const { return applyObservationShift_; }
+        bool applyObservationShift() const { return applyObservationShift_; }
         //@}
         //! \name FloatingRateCoupon interface
         //@{
@@ -99,7 +100,10 @@ namespace QuantLib {
         //! Only when index fixing delay is 0 and observation shift is used,
         //! we can apply telescopic formula, when applying lookback period.
         //@{
-        const bool canApplyTelescopicFormula() const;
+        bool canApplyTelescopicFormula() const {
+            return fixingDays_ == index_->fixingDays() ||
+                (applyObservationShift_ && index_->fixingDays() == 0);
+        }
         //@}
       private:
         std::vector<Date> valueDates_, interestDates_, fixingDates_;
@@ -113,12 +117,6 @@ namespace QuantLib {
         Rate averageRate(const Date& date) const;
     };
 
-    inline const bool OvernightIndexedCoupon::canApplyTelescopicFormula() const {
-        return fixingDays_ == index_->fixingDays() ||
-               (applyObservationShift_ && index_->fixingDays() == 0);
-    }
-
-
     //! helper class building a sequence of overnight coupons
     class OvernightLeg {
       public:
diff --git a/ql/cashflows/overnightindexedcouponpricer.cpp b/ql/cashflows/overnightindexedcouponpricer.cpp
new file mode 100644
index 00000000000..98d78ff9863
--- /dev/null
+++ b/ql/cashflows/overnightindexedcouponpricer.cpp
@@ -0,0 +1,279 @@
+/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*
+ Copyright (C) 2009 Roland Lichters
+ Copyright (C) 2009 Ferdinando Ametrano
+ Copyright (C) 2014 Peter Caspers
+ Copyright (C) 2016 Stefano Fondi
+ Copyright (C) 2017 Joseph Jeisman
+ Copyright (C) 2017 Fabrice Lecuyer
+
+ 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 <ql/cashflows/overnightindexedcouponpricer.hpp>
+
+namespace QuantLib {
+
+    namespace {
+
+        Size determineNumberOfFixings(const std::vector<Date>& interestDates,
+                                      const Date& date,
+                                      bool applyObservationShift) {
+            Size n = std::lower_bound(interestDates.begin(), interestDates.end(), date) -
+                     interestDates.begin();
+            // When using the observation shift, it may happen that
+            // that the end of accrual period will fall later than the last
+            // interest date. In which case, n will be equal to the number of
+            // interest dates, while we know that the number of fixing dates is
+            // always one less than the number of interest dates.
+            return n == interestDates.size() && applyObservationShift ? n - 1 : n;
+        }
+    }
+
+    void CompoundingOvernightIndexedCouponPricer::initialize(const FloatingRateCoupon& coupon) {
+        coupon_ = dynamic_cast<const OvernightIndexedCoupon*>(&coupon);
+        QL_ENSURE(coupon_, "wrong coupon type");
+    }
+
+    Rate CompoundingOvernightIndexedCouponPricer::swapletRate() const {
+        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 = IndexManager::instance().getHistory(index->name());
+
+        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;
+        }
+
+        // today is a border case
+        if (i < n && fixingDates[i] == today) {
+            // might have been fixed
+            try {
+                Rate fixing = pastFixings[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);
+                    ++i;
+                } else {
+                    ; // fall through and forecast
+                }
+            } catch (Error&) {
+                ; // fall through and forecast
+            }
+        }
+
+        // forward part using telescopic property in order
+        // to avoid the evaluation of multiple forward fixings
+        // where possible.
+        if (i < n) {
+            const Handle<YieldTermStructure> curve = index->forwardingTermStructure();
+            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.
+                // Only in one particular case when observation shift is used and
+                // no intrinsic index fixing delay is applied, the telescopic formula
+                // holds, because regardless of the fixing delay in the coupon,
+                // in such configuration value dates will be equal to interest dates.
+                // A potential lockout, which may occur in tandem with a lookback
+                // setting, will be handled automatically based on fixing dates.
+                // 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));
+                    ++i;
+                }
+            } else {
+                // No lookback, we can partially apply the telescopic formula.
+                // But we need to make a correction for a potential lockout.
+                const Size nLockout = n - coupon_->lockoutDays();
+                const bool isLockoutApplied = coupon_->lockoutDays() > 0;
+
+                // Lockout could already start at or before i.
+                // In such case the ratio of discount factors will be equal to 1.
+                const DiscountFactor startDiscount =
+                    curve->discount(valueDates[std::min<Size>(nLockout, i)]);
+                if (interestDates[n] == date || isLockoutApplied) {
+                    // telescopic formula up to potential lockout dates.
+                    const DiscountFactor endDiscount =
+                        curve->discount(valueDates[std::min<Size>(nLockout, n)]);
+                    compoundFactor *= startDiscount / endDiscount;
+                    // For the lockout periods the telescopic formula does not apply.
+                    // The value dates (at which the projection is calculated) correspond
+                    // to the locked-out fixing, while the interest dates (at which the
+                    // interest over that fixing is accrued) are not fixed at lockout,
+                    // hence they do not cancel out.
+                    i = std::max(nLockout, i);
+
+                    // With no lockout, the loop is skipped because i = n.
+                    while (i < n) {
+                        compoundFactor *= (1.0 + effectiveRate(i));
+                        ++i;
+                    }
+                } else {
+                    // No lockout and date is different than last interest date.
+                    // The last fixing is not used for its full period (the date is between
+                    // its start and end date).  We can use the telescopic formula until the
+                    // 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));
+                }
+            }
+        }
+
+        const Rate rate = (compoundFactor - 1.0) / coupon_->accruedPeriod(date);
+        return coupon_->gearing() * rate + coupon_->spread();
+    }
+
+    void
+    ArithmeticAveragedOvernightIndexedCouponPricer::initialize(const FloatingRateCoupon& coupon) {
+        coupon_ = dynamic_cast<const OvernightIndexedCoupon*>(&coupon);
+        QL_ENSURE(coupon_, "wrong coupon type");
+    }
+
+    Rate ArithmeticAveragedOvernightIndexedCouponPricer::swapletRate() const {
+
+        ext::shared_ptr<OvernightIndex> index =
+            ext::dynamic_pointer_cast<OvernightIndex>(coupon_->index());
+
+        const auto& fixingDates = coupon_->fixingDates();
+        const auto& dt = coupon_->dt();
+
+        Size n = dt.size(), i = 0;
+
+        Real accumulatedRate = 0.0;
+
+        // already fixed part
+        Date today = Settings::instance().evaluationDate();
+        while (i < n && fixingDates[i] < today) {
+            // rate must have been fixed
+            Rate pastFixing = IndexManager::instance().getHistory(index->name())[fixingDates[i]];
+            QL_REQUIRE(pastFixing != Null<Real>(),
+                       "Missing " << index->name() << " fixing for " << fixingDates[i]);
+            accumulatedRate += pastFixing * dt[i];
+            ++i;
+        }
+
+        // today is a border case
+        if (i < n && fixingDates[i] == today) {
+            // might have been fixed
+            try {
+                Rate pastFixing =
+                    IndexManager::instance().getHistory(index->name())[fixingDates[i]];
+                if (pastFixing != Null<Real>()) {
+                    accumulatedRate += pastFixing * dt[i];
+                    ++i;
+                } else {
+                    ; // fall through and forecast
+                }
+            } catch (Error&) {
+                ; // fall through and forecast
+            }
+        }
+
+        /* forward part using telescopic property in order
+        to avoid the evaluation of multiple forward fixings
+        (approximation proposed by Katsumi Takada)*/
+        if (byApprox_ && i < n) {
+            Handle<YieldTermStructure> curve = index->forwardingTermStructure();
+            QL_REQUIRE(!curve.empty(),
+                       "null term structure set to this instance of " << index->name());
+
+            const auto& dates = coupon_->valueDates();
+            DiscountFactor startDiscount = curve->discount(dates[i]);
+            DiscountFactor endDiscount = curve->discount(dates[n]);
+
+            accumulatedRate +=
+                log(startDiscount / endDiscount) -
+                convAdj1(curve->timeFromReference(dates[i]), curve->timeFromReference(dates[n])) -
+                convAdj2(curve->timeFromReference(dates[i]), curve->timeFromReference(dates[n]));
+        }
+        // otherwise
+        else if (i < n) {
+            Handle<YieldTermStructure> curve = index->forwardingTermStructure();
+            QL_REQUIRE(!curve.empty(),
+                       "null term structure set to this instance of " << index->name());
+
+            const auto& dates = coupon_->valueDates();
+            Time te = curve->timeFromReference(dates[n]);
+            while (i < n) {
+                // forcast fixing
+                Rate forecastFixing = index->fixing(fixingDates[i]);
+                Time ti1 = curve->timeFromReference(dates[i]);
+                Time ti2 = curve->timeFromReference(dates[i + 1]);
+                /*convexity adjustment due to payment dalay of each
+                overnight fixing, supposing an Hull-White short rate model*/
+                Real convAdj = exp(
+                    0.5 * pow(vol_, 2.0) / pow(mrs_, 3.0) * (exp(2 * mrs_ * ti1) - 1) *
+                    (exp(-mrs_ * ti2) - exp(-mrs_ * te)) * (exp(-mrs_ * ti2) - exp(-mrs_ * ti1)));
+                accumulatedRate += convAdj * (1 + forecastFixing * dt[i]) - 1;
+                ++i;
+            }
+        }
+
+        Rate rate = accumulatedRate / coupon_->accrualPeriod();
+        return coupon_->gearing() * rate + coupon_->spread();
+    }
+
+    Real ArithmeticAveragedOvernightIndexedCouponPricer::convAdj1(Time ts, Time te) const {
+        return vol_ * vol_ / (4.0 * pow(mrs_, 3.0)) * (1.0 - exp(-2.0 * mrs_ * ts)) *
+               pow((1.0 - exp(-mrs_ * (te - ts))), 2.0);
+    }
+
+    Real ArithmeticAveragedOvernightIndexedCouponPricer::convAdj2(Time ts, Time te) const {
+        return vol_ * vol_ / (2.0 * pow(mrs_, 2.0)) *
+               ((te - ts) - pow(1.0 - exp(-mrs_ * (te - ts)), 2.0) / mrs_ -
+                (1.0 - exp(-2.0 * mrs_ * (te - ts))) / (2.0 * mrs_));
+    }
+}
diff --git a/ql/cashflows/overnightindexedcouponpricer.hpp b/ql/cashflows/overnightindexedcouponpricer.hpp
new file mode 100644
index 00000000000..984af3cf2ac
--- /dev/null
+++ b/ql/cashflows/overnightindexedcouponpricer.hpp
@@ -0,0 +1,91 @@
+/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*
+ Copyright (C) 2009 Roland Lichters
+ Copyright (C) 2009 Ferdinando Ametrano
+ Copyright (C) 2014 Peter Caspers
+ Copyright (C) 2016 Stefano Fondi
+ Copyright (C) 2017 Joseph Jeisman
+ Copyright (C) 2017 Fabrice Lecuyer
+
+ 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.
+*/
+
+/*! \file overnightindexedcouponpricer.hpp
+    \brief contains the pricer for an OvernightIndexedCoupon
+*/
+
+#ifndef quantlib_overnight_indexed_coupon_pricer_hpp
+#define quantlib_overnight_indexed_coupon_pricer_hpp
+
+#include <ql/cashflows/couponpricer.hpp>
+#include <ql/cashflows/floatingratecoupon.hpp>
+#include <ql/cashflows/overnightindexedcoupon.hpp>
+
+namespace QuantLib {
+
+    //! CompoudAveragedOvernightIndexedCouponPricer pricer
+    class CompoundingOvernightIndexedCouponPricer : public FloatingRateCouponPricer {
+      public:
+        //! \name FloatingRateCoupon interface
+        //@{
+        void initialize(const FloatingRateCoupon& coupon) override;
+        Rate swapletRate() const override;
+        Real swapletPrice() const override { QL_FAIL("swapletPrice not available"); }
+        Real capletPrice(Rate) const override { QL_FAIL("capletPrice not available"); }
+        Rate capletRate(Rate) const override { QL_FAIL("capletRate not available"); }
+        Real floorletPrice(Rate) const override { QL_FAIL("floorletPrice not available"); }
+        Rate floorletRate(Rate) const override { QL_FAIL("floorletRate not available"); }
+        //@}
+        Rate averageRate(const Date& date) const;
+
+      protected:
+        const OvernightIndexedCoupon* coupon_ = nullptr;
+    };
+
+    /*! pricer for arithmetically averaged overnight indexed coupons
+    Reference: Katsumi Takada 2011, Valuation of Arithmetically Average of
+    Fed Funds Rates and Construction of the US Dollar Swap Yield Curve
+    */
+    class ArithmeticAveragedOvernightIndexedCouponPricer : public FloatingRateCouponPricer {
+      public:
+        explicit ArithmeticAveragedOvernightIndexedCouponPricer(
+            Real meanReversion = 0.03,
+            Real volatility = 0.00, // NO convexity adjustment by default
+            bool byApprox = false)  // TRUE to use Katsumi Takada approximation
+        : byApprox_(byApprox), mrs_(meanReversion), vol_(volatility) {}
+
+        explicit ArithmeticAveragedOvernightIndexedCouponPricer(
+            bool byApprox) // Simplified constructor assuming no convexity correction
+        : ArithmeticAveragedOvernightIndexedCouponPricer(0.03, 0.0, byApprox) {}
+
+        void initialize(const FloatingRateCoupon& coupon) override;
+        Rate swapletRate() const override;
+        Real swapletPrice() const override { QL_FAIL("swapletPrice not available"); }
+        Real capletPrice(Rate) const override { QL_FAIL("capletPrice not available"); }
+        Rate capletRate(Rate) const override { QL_FAIL("capletRate not available"); }
+        Real floorletPrice(Rate) const override { QL_FAIL("floorletPrice not available"); }
+        Rate floorletRate(Rate) const override { QL_FAIL("floorletRate not available"); }
+
+      protected:
+        Real convAdj1(Time ts, Time te) const;
+        Real convAdj2(Time ts, Time te) const;
+        const OvernightIndexedCoupon* coupon_;
+        bool byApprox_;
+        Real mrs_;
+        Real vol_;
+    };
+}
+
+#endif
diff --git a/ql/experimental/averageois/Makefile.am b/ql/experimental/averageois/Makefile.am
index 745b1654eaf..c1909dd7d09 100644
--- a/ql/experimental/averageois/Makefile.am
+++ b/ql/experimental/averageois/Makefile.am
@@ -10,7 +10,6 @@ this_include_HEADERS = \
     makearithmeticaverageois.hpp
 
 cpp_files = \
-    averageoiscouponpricer.cpp \
     arithmeticaverageois.cpp \
     arithmeticoisratehelper.cpp \
     makearithmeticaverageois.cpp
diff --git a/ql/experimental/averageois/arithmeticaverageois.cpp b/ql/experimental/averageois/arithmeticaverageois.cpp
index e779e5a73af..ee6e0ff9117 100644
--- a/ql/experimental/averageois/arithmeticaverageois.cpp
+++ b/ql/experimental/averageois/arithmeticaverageois.cpp
@@ -19,8 +19,8 @@
 
 #include <ql/cashflows/fixedratecoupon.hpp>
 #include <ql/cashflows/overnightindexedcoupon.hpp>
+#include <ql/cashflows/overnightindexedcouponpricer.hpp>
 #include <ql/experimental/averageois/arithmeticaverageois.hpp>
-#include <ql/experimental/averageois/averageoiscouponpricer.hpp>
 #include <utility>
 
 namespace QuantLib {
diff --git a/ql/experimental/averageois/averageoiscouponpricer.cpp b/ql/experimental/averageois/averageoiscouponpricer.cpp
deleted file mode 100644
index 5bcbd873041..00000000000
--- a/ql/experimental/averageois/averageoiscouponpricer.cpp
+++ /dev/null
@@ -1,146 +0,0 @@
-/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-
-/*
- Copyright (C) 2016 Stefano Fondi
-
- 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 <ql/experimental/averageois/averageoiscouponpricer.hpp>
-#include <cmath>
-
-using std::vector;
-using std::exp;
-using std::pow;
-using std::log;
-
-namespace QuantLib {
-
-    void ArithmeticAveragedOvernightIndexedCouponPricer::initialize(
-                                            const FloatingRateCoupon& coupon) {
-        coupon_ = dynamic_cast<const OvernightIndexedCoupon*>(&coupon);
-        QL_ENSURE(coupon_, "wrong coupon type");
-    }
-
-    Rate ArithmeticAveragedOvernightIndexedCouponPricer::swapletRate() const {
-
-        ext::shared_ptr<OvernightIndex> index =
-            ext::dynamic_pointer_cast<OvernightIndex>(coupon_->index());
-
-        const vector<Date>& fixingDates = coupon_->fixingDates();
-        const vector<Time>& dt = coupon_->dt();
-
-        Size n = dt.size(),
-            i = 0;
-
-        Real accumulatedRate = 0.0;
-
-        // already fixed part
-        Date today = Settings::instance().evaluationDate();
-        while (i < n && fixingDates[i] < today) {
-            // rate must have been fixed
-            Rate pastFixing = IndexManager::instance().getHistory(
-                index->name())[fixingDates[i]];
-            QL_REQUIRE(pastFixing != Null<Real>(),
-                "Missing " << index->name() <<
-                " fixing for " << fixingDates[i]);
-            accumulatedRate += pastFixing*dt[i];
-            ++i;
-        }
-
-        // today is a border case
-        if (i < n && fixingDates[i] == today) {
-            // might have been fixed
-            try {
-                Rate pastFixing = IndexManager::instance().getHistory(
-                    index->name())[fixingDates[i]];
-                if (pastFixing != Null<Real>()) {
-                    accumulatedRate += pastFixing*dt[i];
-                    ++i;
-                }
-                else {
-                    ;   // fall through and forecast
-                }
-            }
-            catch (Error&) {
-                ;       // fall through and forecast
-            }
-        }
-
-        /* forward part using telescopic property in order
-        to avoid the evaluation of multiple forward fixings
-        (approximation proposed by Katsumi Takada)*/
-        if (byApprox_ && i < n) {
-            Handle<YieldTermStructure> curve =
-                index->forwardingTermStructure();
-            QL_REQUIRE(!curve.empty(),
-                "null term structure set to this instance of " <<
-                index->name());
-
-            const vector<Date>& dates = coupon_->valueDates();
-            DiscountFactor startDiscount = curve->discount(dates[i]);
-            DiscountFactor endDiscount = curve->discount(dates[n]);
-
-            accumulatedRate += log(startDiscount / endDiscount) - 
-                convAdj1(curve->timeFromReference(dates[i]),
-                         curve->timeFromReference(dates[n])) -
-                convAdj2(curve->timeFromReference(dates[i]),
-                         curve->timeFromReference(dates[n]));
-        }
-        // otherwise
-        else if (i < n){
-            Handle<YieldTermStructure> curve =
-                index->forwardingTermStructure();
-            QL_REQUIRE(!curve.empty(),
-                "null term structure set to this instance of " <<
-                index->name());
-
-            const vector<Date>& dates = coupon_->valueDates();
-            Time te = curve->timeFromReference(dates[n]);
-            while (i < n) {
-                // forcast fixing
-                Rate forecastFixing = index->fixing(fixingDates[i]);
-                Time ti1 = curve->timeFromReference(dates[i]);
-                Time ti2 = curve->timeFromReference(dates[i + 1]);
-                /*convexity adjustment due to payment dalay of each
-                overnight fixing, supposing an Hull-White short rate model*/
-                Real convAdj = exp( 0.5*pow(vol_, 2.0) / pow(mrs_, 3.0)*
-                    (exp(2 * mrs_*ti1) - 1)*
-                    (exp(-mrs_*ti2) - exp(-mrs_*te))*
-                    (exp(-mrs_*ti2) - exp(-mrs_*ti1)) );
-                accumulatedRate += convAdj*(1 + forecastFixing*dt[i]) - 1;
-                ++i;
-            }
-        }
-
-        Rate rate = accumulatedRate / coupon_->accrualPeriod();
-        return coupon_->gearing() * rate + coupon_->spread();
-    }
-
-    Real ArithmeticAveragedOvernightIndexedCouponPricer::convAdj1(
-                                                    Time ts, Time te) const {
-        return vol_ * vol_ / (4.0 * pow(mrs_, 3.0)) *
-            (1.0 - exp(-2.0*mrs_*ts)) *
-            pow((1.0 - exp(-mrs_*(te - ts))), 2.0);
-    }
-
-    Real ArithmeticAveragedOvernightIndexedCouponPricer::convAdj2(
-                                                    Time ts, Time te) const {
-        return vol_ * vol_ / (2.0 * pow(mrs_, 2.0)) * ((te - ts) -
-            pow(1.0 - exp(-mrs_*(te - ts)), 2.0) / mrs_ -
-            (1.0 - exp(-2.0*mrs_*(te - ts))) / (2.0 * mrs_));
-    }
-
-}
-
diff --git a/ql/experimental/averageois/averageoiscouponpricer.hpp b/ql/experimental/averageois/averageoiscouponpricer.hpp
index f8ef37ca43a..ea3bc6734a7 100644
--- a/ql/experimental/averageois/averageoiscouponpricer.hpp
+++ b/ql/experimental/averageois/averageoiscouponpricer.hpp
@@ -17,53 +17,12 @@
  FOR A PARTICULAR PURPOSE.  See the license for more details.
 */
 
-/*! \file averageoiscouponpricer.hpp
-    \brief pricer for arithmetically-averaged overnight-indexed coupons
-*/
-
 #ifndef quantlib_average_ois_coupon_pricer_hpp
 #define quantlib_average_ois_coupon_pricer_hpp
 
-#include <ql/cashflows/overnightindexedcoupon.hpp>
-#include <ql/cashflows/couponpricer.hpp>
-
-namespace QuantLib {
-
-    /*! pricer for arithmetically averaged overnight indexed coupons
-    Reference: Katsumi Takada 2011, Valuation of Arithmetically Average of
-    Fed Funds Rates and Construction of the US Dollar Swap Yield Curve
-    */
-    class ArithmeticAveragedOvernightIndexedCouponPricer
-                                         : public FloatingRateCouponPricer {
-    public:
-        explicit ArithmeticAveragedOvernightIndexedCouponPricer(
-            Real meanReversion = 0.03,
-            Real volatility = 0.00, // NO convexity adjustment by default
-            bool byApprox = false) // TRUE to use Katsumi Takada approximation
-        : byApprox_(byApprox), mrs_(meanReversion), vol_(volatility) {}
-
-        explicit ArithmeticAveragedOvernightIndexedCouponPricer(
-            bool byApprox)  // Simplified constructor assuming no convexity correction
-        : ArithmeticAveragedOvernightIndexedCouponPricer(0.03, 0.0, byApprox) {}
-
-        void initialize(const FloatingRateCoupon& coupon) override;
-        Rate swapletRate() const override;
-        Real swapletPrice() const override { QL_FAIL("swapletPrice not available"); }
-        Real capletPrice(Rate) const override { QL_FAIL("capletPrice not available"); }
-        Rate capletRate(Rate) const override { QL_FAIL("capletRate not available"); }
-        Real floorletPrice(Rate) const override { QL_FAIL("floorletPrice not available"); }
-        Rate floorletRate(Rate) const override { QL_FAIL("floorletRate not available"); }
-
-      protected:
-        Real convAdj1(Time ts, Time te) const;
-        Real convAdj2(Time ts, Time te) const;
-        const OvernightIndexedCoupon* coupon_;
-        bool byApprox_;
-        Real mrs_;
-        Real vol_;
-
-    };
+// Deprecated in version 1.36
+#pragma message("Warning: this file will disappear in a future release; include <ql/cashflows/overnightindexedcouponpricer.hpp> instead")
 
-}
+#include <ql/cashflows/overnightindexedcouponpricer.hpp>
 
 #endif