Why isn't the lifetime of the temporary extended in this case?

  Let's assume we have a class like this:

//---------------------------------------------------------
#include <iostream>

class MyClass
{
 public:
    MyClass() { std::cout << "constructor\n"; }
    ~MyClass() { std::cout << "destructor\n"; }

    const MyClass& print(int i) const
    {
        std::cout << i << std::endl;
        return *this;
    }
};
//---------------------------------------------------------

  Now, if I create a reference to a temporary instance of this class,
the lifetime of that instance will be extended for the lifetime of the
reference. For example:

//---------------------------------------------------------
int main()
{
    std::cout << "Before\n";
    const MyClass& obj = MyClass(); //*
    std::cout << "After\n";
    obj.print(2);
}
//---------------------------------------------------------

  This program will print:

Before
constructor
After
2
destructor

  This is even so if the temporary is the return value of a function.
For example, let's assume we have the function:

MyClass getMyClass() { return MyClass(); }

  Now if we change the line marked with //* to this:

    const MyClass& obj = getMyClass(); //*

the result will still be the same. So clearly the lifetime of the return
value of a function is extended by the reference.

  Now comes the puzzling part, and my actual question. Suppose that we
change the line marked with //* to this:

    const MyClass& obj = MyClass().print(1); //*

  Suddenly the output changes:

Before
constructor
1
destructor
After
2

  Now the temporary object is destroyed after the reference assignment
ends! The second print() call is now calling a destroyed object! (Oddly
gcc doesn't issue even a warning about this.)

  The same is true for:

    const MyClass& obj = getMyClass().print(1); //*

  But why? Why does the print() function returning a reference to itself
change the semantics of the lifetime of the temporary object? Why isn't
the reference extending the lifetime of the object anymore? Why does the
reference extend the lifetime of the return value of getMyClass(), but
not the lifetime of the return value of MyClass::print()? How does it
make even sense that a reference can be created to an object which is
destroyed immediately after the reference is created?