Is cout guaranteed available during static deinitialization?

I've got a quasi-singleton class (quasi-singleton in that most use refers to a single object that is a function static, but users can also construct their own local copy for short-term use) that I would like to have write to cout from its destructor, and wanted to know if cout was guaranteed to be available during the static deinitialization phase following program termination. From this question it seems that the answer is yes (function static initialized objects should have their destructors called in reverse order from when they were constructed, which should be after cout was set up), but I wanted to check.

// Count calls to a logging function from some point in our code, to determine
// how many times it gets executed during a run, then report calls at the end
// of the program.  A quick-and-dirty way of determining how often we execute
// code.
class callCounter;
class callCounter {
public:
    callCounter() : has_calls_(false), counts_() {}
    ~callCounter () {report(std::cout);}
    void logCall(const std::string callSite);
    void report(std::ostream &os);
    void reset();
    static callCounter *theCounter();
private:
    typedef std::map<std::string, callCount> COUNTMAP;
    bool has_calls_;
    COUNTMAP counts_;
};

callCounter *callCounter::theCounter()
{
    static callCounter theCounts;
    return &theCounts;
}

Typical usage would be:

callCounter::theCounter()->logCall("foo");

So is this usage of cout in the destructor guaranteed safe (at least as far as using cout itself is concerned - arguably to be perfectly safe, I should wrap the report in a try block in case the write throws an exception.)?