diff --git a/tree/ntuple/inc/ROOT/RNTupleProcessor.hxx b/tree/ntuple/inc/ROOT/RNTupleProcessor.hxx
index b97f36b031da1..b59d983c39112 100644
--- a/tree/ntuple/inc/ROOT/RNTupleProcessor.hxx
+++ b/tree/ntuple/inc/ROOT/RNTupleProcessor.hxx
@@ -273,9 +273,7 @@ protected:
    /// interface.
    ROOT::NTupleSize_t fNEntries = kInvalidNTupleIndex;
 
-   ROOT::NTupleSize_t fNEntriesProcessed = 0;  //< Total number of entries processed so far
-   ROOT::NTupleSize_t fCurrentEntryNumber = 0; //< Current processor entry number
-   std::size_t fCurrentProcessorNumber = 0;    //< Number of the currently open inner processor
+   ROOT::NTupleSize_t fNEntriesProcessed = 0; //< Total number of entries processed so far
 
    /////////////////////////////////////////////////////////////////////////////
    /// \brief Initialize the processor by creating an (initially empty) `fEntry`, or setting an existing one.
@@ -367,16 +365,6 @@ public:
    /// \brief Get the total number of entries processed so far.
    ROOT::NTupleSize_t GetNEntriesProcessed() const { return fNEntriesProcessed; }
 
-   /////////////////////////////////////////////////////////////////////////////
-   /// \brief Get the entry number that is currently being processed.
-   ROOT::NTupleSize_t GetCurrentEntryNumber() const { return fCurrentEntryNumber; }
-
-   /////////////////////////////////////////////////////////////////////////////
-   /// \brief Get the number of the inner processor currently being read.
-   ///
-   /// This method is only relevant for the RNTupleChainProcessor. For the other processors, 0 is always returned.
-   std::size_t GetCurrentProcessorNumber() const { return fCurrentProcessorNumber; }
-
    /////////////////////////////////////////////////////////////////////////////
    /// \brief Request access to a field for reading during processing.
    ///
@@ -691,6 +679,9 @@ private:
    std::vector<std::unique_ptr<RNTupleProcessor>> fInnerProcessors;
    std::vector<ROOT::NTupleSize_t> fInnerNEntries;
 
+   ROOT::NTupleSize_t fLastLoadedEntry = 0; //< Last (global) entry number that was loaded
+   std::size_t fCurrentProcessorNumber = 0; //< Number of the currently open inner processor
+
    Internal::RNTupleProcessorProvenance fProvenance;
 
    /////////////////////////////////////////////////////////////////////////////
diff --git a/tree/ntuple/src/RNTupleProcessor.cxx b/tree/ntuple/src/RNTupleProcessor.cxx
index a634cac6e3ce7..a36f324be0356 100644
--- a/tree/ntuple/src/RNTupleProcessor.cxx
+++ b/tree/ntuple/src/RNTupleProcessor.cxx
@@ -223,7 +223,6 @@ ROOT::NTupleSize_t ROOT::Experimental::RNTupleSingleProcessor::LoadEntry(ROOT::N
    }
 
    fNEntriesProcessed++;
-   fCurrentEntryNumber = entryNumber;
    return entryNumber;
 }
 
@@ -351,7 +350,7 @@ ROOT::NTupleSize_t ROOT::Experimental::RNTupleChainProcessor::LoadEntry(ROOT::NT
    // If the requested entry number is lower than the current entry number, we have to again localise the correct local
    // entry number starting from the first processor in the chain. Otherwise, we can continue looking from the inner
    // processor that is currently connected, which is much faster when the chain consists of many inner processors.
-   if (entryNumber < fCurrentEntryNumber) {
+   if (entryNumber < fLastLoadedEntry) {
       fCurrentProcessorNumber = 0;
       ConnectInnerProcessor(fCurrentProcessorNumber);
    }
@@ -384,7 +383,7 @@ ROOT::NTupleSize_t ROOT::Experimental::RNTupleChainProcessor::LoadEntry(ROOT::NT
 
    fCurrentProcessorNumber = currProcessorNumber;
    fNEntriesProcessed++;
-   fCurrentEntryNumber = entryNumber;
+   fLastLoadedEntry = entryNumber;
    return entryNumber;
 }
 
@@ -526,7 +525,6 @@ ROOT::NTupleSize_t ROOT::Experimental::RNTupleJoinProcessor::LoadEntry(ROOT::NTu
       return kInvalidNTupleIndex;
    }
 
-   fCurrentEntryNumber = entryNumber;
    fNEntriesProcessed++;
 
    if (!fJoinTable) {
diff --git a/tree/ntuple/test/ntuple_processor.cxx b/tree/ntuple/test/ntuple_processor.cxx
index cd58f2ea0770d..312dc85e8f30b 100644
--- a/tree/ntuple/test/ntuple_processor.cxx
+++ b/tree/ntuple/test/ntuple_processor.cxx
@@ -49,7 +49,6 @@ TEST(RNTupleProcessor, TMemFile)
 
    for (auto idx : *proc) {
       EXPECT_EQ(idx + 1, proc->GetNEntriesProcessed());
-      EXPECT_EQ(idx, proc->GetCurrentEntryNumber());
 
       EXPECT_FLOAT_EQ(static_cast<float>(idx), *x);
    }
@@ -79,7 +78,6 @@ TEST(RNTupleProcessor, TDirectory)
 
    for (auto idx : *proc) {
       EXPECT_EQ(idx + 1, proc->GetNEntriesProcessed());
-      EXPECT_EQ(idx, proc->GetCurrentEntryNumber());
 
       EXPECT_FLOAT_EQ(static_cast<float>(idx), *x);
    }
@@ -186,7 +184,6 @@ TEST_F(RNTupleProcessorTest, Base)
    }
 
    for (auto idx : *proc) {
-      EXPECT_EQ(idx, proc->GetCurrentEntryNumber());
       EXPECT_EQ(idx + 1, proc->GetNEntriesProcessed());
 
       EXPECT_FLOAT_EQ(static_cast<float>(idx), *x);
@@ -258,7 +255,6 @@ TEST_F(RNTupleProcessorTest, RequestFieldWithTypeString)
    auto y = proc->RequestField("y", "std::vector<float>", yPtr.get());
 
    for (auto idx : *proc) {
-      EXPECT_EQ(idx, proc->GetCurrentEntryNumber());
       EXPECT_EQ(idx + 1, proc->GetNEntriesProcessed());
 
       EXPECT_FLOAT_EQ(static_cast<float>(idx), *std::static_pointer_cast<float>(x.GetPtr()));
@@ -286,7 +282,6 @@ TEST_F(RNTupleProcessorTest, AlternativeTypes)
    auto yAsRVec = proc->RequestField<ROOT::RVec<float>>("y");
 
    for (auto idx : *proc) {
-      EXPECT_EQ(idx, proc->GetCurrentEntryNumber());
 
       EXPECT_FLOAT_EQ(static_cast<double>(idx), *xAsDouble);
       EXPECT_FLOAT_EQ(idx, *xAsFloat);
@@ -341,7 +336,6 @@ TEST_F(RNTupleProcessorTest, ChainedChain)
 
    for (auto idx : *proc) {
       EXPECT_EQ(idx + 1, proc->GetNEntriesProcessed());
-      EXPECT_EQ(idx, proc->GetCurrentEntryNumber());
       if ((idx >= 5 && idx < 10) || idx >= 15) {
          EXPECT_EQ(*i, 4 - idx % 5);
          EXPECT_EQ(*z, (4 - idx % 5) * 3.f);
@@ -361,7 +355,6 @@ TEST_F(RNTupleProcessorTest, ChainedChain)
 
    for (auto idx : *proc) {
       EXPECT_EQ(idx + 1 + 20, proc->GetNEntriesProcessed());
-      EXPECT_EQ(idx, proc->GetCurrentEntryNumber());
 
       if ((idx >= 5 && idx < 10) || idx >= 15) {
          EXPECT_EQ(*i, 4 - idx % 5);
@@ -395,8 +388,7 @@ TEST_F(RNTupleProcessorTest, ChainedJoin)
 
    for (auto idx : *proc) {
       EXPECT_EQ(idx + 1, proc->GetNEntriesProcessed());
-      EXPECT_EQ(idx, proc->GetCurrentEntryNumber());
-      EXPECT_EQ(*i, proc->GetCurrentEntryNumber() % 5);
+      EXPECT_EQ(*i, idx % 5);
 
       EXPECT_EQ(static_cast<float>(*i), *x);
       EXPECT_EQ(*x * 2, *z);
@@ -422,8 +414,7 @@ TEST_F(RNTupleProcessorTest, ChainedJoinUnaligned)
 
    for (auto idx : *proc) {
       EXPECT_EQ(idx + 1, proc->GetNEntriesProcessed());
-      EXPECT_EQ(idx, proc->GetCurrentEntryNumber());
-      EXPECT_EQ(*i, proc->GetCurrentEntryNumber() % 5);
+      EXPECT_EQ(*i, idx % 5);
 
       EXPECT_EQ(static_cast<float>(*i), *x);
       EXPECT_EQ(*x * 3, *z);
@@ -449,8 +440,7 @@ TEST_F(RNTupleProcessorTest, ChainedJoinMissingEntries)
 
    for (auto idx : *proc) {
       EXPECT_EQ(idx + 1, proc->GetNEntriesProcessed());
-      EXPECT_EQ(idx, proc->GetCurrentEntryNumber());
-      EXPECT_EQ(*i, proc->GetCurrentEntryNumber() % 5);
+      EXPECT_EQ(*i, idx % 5);
 
       EXPECT_EQ(static_cast<float>(*i), *x);
 
@@ -484,8 +474,7 @@ TEST_F(RNTupleProcessorTest, JoinedChain)
 
    for (auto idx : *proc) {
       EXPECT_EQ(idx + 1, proc->GetNEntriesProcessed());
-      EXPECT_EQ(idx, proc->GetCurrentEntryNumber());
-      EXPECT_EQ(*i, proc->GetCurrentEntryNumber() % 5);
+      EXPECT_EQ(*i, idx % 5);
 
       EXPECT_EQ(static_cast<float>(*i), *x);
       EXPECT_EQ(*x * 2, *z);
@@ -511,8 +500,7 @@ TEST_F(RNTupleProcessorTest, JoinedChainUnaligned)
 
    for (auto idx : *proc) {
       EXPECT_EQ(idx + 1, proc->GetNEntriesProcessed());
-      EXPECT_EQ(idx, proc->GetCurrentEntryNumber());
-      EXPECT_EQ(*i, proc->GetCurrentEntryNumber() % 5);
+      EXPECT_EQ(*i, idx % 5);
 
       EXPECT_EQ(static_cast<float>(*i), *x);
       EXPECT_EQ(*x * 3, *z);
@@ -538,8 +526,7 @@ TEST_F(RNTupleProcessorTest, JoinedChainMissingEntries)
 
    for (auto idx : *proc) {
       EXPECT_EQ(idx + 1, proc->GetNEntriesProcessed());
-      EXPECT_EQ(idx, proc->GetCurrentEntryNumber());
-      EXPECT_EQ(*i, proc->GetCurrentEntryNumber() % 5);
+      EXPECT_EQ(*i, idx % 5);
 
       EXPECT_EQ(static_cast<float>(*i), *x);
 
@@ -662,8 +649,7 @@ TEST_F(RNTupleProcessorTest, JoinedJoinComposedPrimary)
 
    for (auto idx : *proc) {
       EXPECT_EQ(idx + 1, proc->GetNEntriesProcessed());
-      EXPECT_EQ(idx, proc->GetCurrentEntryNumber());
-      EXPECT_EQ(*i, proc->GetCurrentEntryNumber() % 5);
+      EXPECT_EQ(*i, idx % 5);
 
       EXPECT_EQ(static_cast<float>(*i), *x);
       EXPECT_EQ(*x * 2, *z1);
@@ -694,8 +680,7 @@ TEST_F(RNTupleProcessorTest, JoinedJoinComposedPrimaryMissingEntries)
 
    for (auto idx : *proc) {
       EXPECT_EQ(idx + 1, proc->GetNEntriesProcessed());
-      EXPECT_EQ(idx, proc->GetCurrentEntryNumber());
-      EXPECT_EQ(*i, proc->GetCurrentEntryNumber() % 5);
+      EXPECT_EQ(*i, idx % 5);
 
       EXPECT_EQ(static_cast<float>(*i), *x);
       EXPECT_EQ(*x * 2, *z1);
@@ -736,8 +721,7 @@ TEST_F(RNTupleProcessorTest, JoinedJoinComposedAuxiliary)
 
    for (auto idx : *proc) {
       EXPECT_EQ(idx + 1, proc->GetNEntriesProcessed());
-      EXPECT_EQ(idx, proc->GetCurrentEntryNumber());
-      EXPECT_EQ(*i, proc->GetCurrentEntryNumber() % 5);
+      EXPECT_EQ(*i, idx % 5);
 
       EXPECT_EQ(static_cast<float>(*i), *x);
       EXPECT_EQ(*x * 2, *z1);
@@ -771,8 +755,7 @@ TEST_F(RNTupleProcessorTest, JoinedJoinComposedAuxiliaryMissingEntries)
 
    for (auto idx : *proc) {
       EXPECT_EQ(idx + 1, proc->GetNEntriesProcessed());
-      EXPECT_EQ(idx, proc->GetCurrentEntryNumber());
-      EXPECT_EQ(*i, proc->GetCurrentEntryNumber() % 5);
+      EXPECT_EQ(*i, idx % 5);
 
       EXPECT_EQ(static_cast<float>(*i), *x);
       EXPECT_EQ(*x * 2, *z1);
diff --git a/tree/ntuple/test/ntuple_processor_chain.cxx b/tree/ntuple/test/ntuple_processor_chain.cxx
index f2a9c6d746ff9..c4443972430a2 100644
--- a/tree/ntuple/test/ntuple_processor_chain.cxx
+++ b/tree/ntuple/test/ntuple_processor_chain.cxx
@@ -89,9 +89,7 @@ TEST_F(RNTupleChainProcessorTest, SingleNTuple)
 
    for (auto idx : *proc) {
       EXPECT_EQ(idx + 1, proc->GetNEntriesProcessed());
-      EXPECT_EQ(idx, proc->GetCurrentEntryNumber());
-
-      EXPECT_FLOAT_EQ(static_cast<float>(proc->GetCurrentEntryNumber()), *x);
+      EXPECT_FLOAT_EQ(static_cast<float>(idx), *x);
    }
    EXPECT_EQ(5, proc->GetNEntriesProcessed());
 }
@@ -115,8 +113,6 @@ TEST_F(RNTupleChainProcessorTest, Basic)
 
    for (auto idx : *proc) {
       EXPECT_EQ(idx + 1, proc->GetNEntriesProcessed());
-      EXPECT_EQ(idx, proc->GetCurrentEntryNumber());
-
       EXPECT_EQ(static_cast<float>(idx), *x);
 
       std::vector<float> yExp = {static_cast<float>(idx), static_cast<float>((idx) * 2)};
@@ -196,19 +192,15 @@ TEST_F(RNTupleChainProcessorTest, LoadRandomEntry)
 
    RNTupleProcessorEntryLoader::LoadEntry(*proc, 3);
    EXPECT_EQ(3.f, *x);
-   EXPECT_EQ(0, proc->GetCurrentProcessorNumber());
 
    RNTupleProcessorEntryLoader::LoadEntry(*proc, 9);
    EXPECT_EQ(9.f, *x);
-   EXPECT_EQ(1, proc->GetCurrentProcessorNumber());
 
    RNTupleProcessorEntryLoader::LoadEntry(*proc, 6);
    EXPECT_EQ(6.f, *x);
-   EXPECT_EQ(1, proc->GetCurrentProcessorNumber());
 
    RNTupleProcessorEntryLoader::LoadEntry(*proc, 2);
    EXPECT_EQ(2.f, *x);
-   EXPECT_EQ(0, proc->GetCurrentProcessorNumber());
 
    EXPECT_EQ(ROOT::kInvalidNTupleIndex, RNTupleProcessorEntryLoader::LoadEntry(*proc, 10));
 }
@@ -235,8 +227,6 @@ TEST_F(RNTupleChainProcessorTest, TMemFile)
 
    for (auto idx : *proc) {
       EXPECT_EQ(idx + 1, proc->GetNEntriesProcessed());
-      EXPECT_EQ(idx, proc->GetCurrentEntryNumber());
-
       EXPECT_EQ(static_cast<float>(idx), *x);
    }
    EXPECT_EQ(10, proc->GetNEntriesProcessed());
diff --git a/tree/ntuple/test/ntuple_processor_join.cxx b/tree/ntuple/test/ntuple_processor_join.cxx
index 5bd235cbae4b1..ef6ef47c2f292 100644
--- a/tree/ntuple/test/ntuple_processor_join.cxx
+++ b/tree/ntuple/test/ntuple_processor_join.cxx
@@ -97,7 +97,6 @@ TEST_F(RNTupleJoinProcessorTest, Aligned)
 
    for (auto idx : *proc) {
       EXPECT_EQ(idx + 1, proc->GetNEntriesProcessed());
-      EXPECT_EQ(idx, proc->GetCurrentEntryNumber());
 
       yExpected = {static_cast<float>(*i * 0.2), 3.14, static_cast<float>(*i * 1.3)};
       EXPECT_EQ(yExpected, *y);
@@ -234,9 +233,9 @@ TEST_F(RNTupleJoinProcessorTest, UnalignedMultipleJoinFields)
    auto a = proc->RequestField<float>("ntuple4.a");
 
    for (auto idx : *proc) {
-      EXPECT_EQ(proc->GetCurrentEntryNumber(), idx);
+      EXPECT_EQ(proc->GetNEntriesProcessed(), idx + 1);
 
-      EXPECT_FLOAT_EQ(proc->GetCurrentEntryNumber() * 2, *i);
+      EXPECT_FLOAT_EQ(idx * 2, *i);
       EXPECT_FLOAT_EQ(*i * 0.5f, *x);
       EXPECT_EQ(*i * 0.1f, *a);
    }
diff --git a/tutorials/io/ntuple/ntpl012_processor_chain.C b/tutorials/io/ntuple/ntpl012_processor_chain.C
index 99e800493e894..6b7c84dcd066e 100644
--- a/tutorials/io/ntuple/ntpl012_processor_chain.C
+++ b/tutorials/io/ntuple/ntpl012_processor_chain.C
@@ -75,13 +75,6 @@ void Read(const std::vector<RNTupleOpenSpec> &ntuples)
 
    // The iterator value is the index of the current entry being processed.
    for (auto idx : *processor) {
-      // The RNTupleProcessor provides some additional bookkeeping information, such as the current processor number.
-      if (static_cast<int>(processor->GetCurrentProcessorNumber()) > prevProcessorNumber) {
-         prevProcessorNumber = processor->GetCurrentProcessorNumber();
-         std::cout << "Processing `ntuple" << prevProcessorNumber + 1 << "` (" << idx + 1
-                   << " total entries processed so far)" << std::endl;
-      }
-
       // We use the value returned from requesting the field to read its data for the current entry.
       for (auto x : *px) {
          hPx.Fill(x);