Subclassed Python Counter for a more visually user-friendly __str__() method, for anagrams
1. Review


There is no docstring. What kind of object is a LetterCounter?
The Python style guide recommends restricting lines to 79 characters. If you did this, then we wouldn't have to scroll the code horizontally to read it.
The Python style guide recommends naming constants (like superscript_digits) using ALL_CAPITALS. It's not compulsory to follow this guide but it makes it easier to collaborate with other Python programmers.
Instead of:

superscript_digits = ''.join(['\u2070','\u00b9','\u00b2','\u00b3','\u2074','\u2075','\u2076','\u2077','\u2078','\u2079'])


add an encoding declaration to the start of the source code:

# -*- coding: utf-8 -*-


and write:

SUPERSCRIPT_DIGITS = "⁰¹²³⁴⁵⁶⁷⁸⁹"

The function int_to_superscript is short, and only called once, so it would make sense to inline it at its single point of use.
There is no need for the call to list in sorted(list(self.items())): sorted accepts an iterable.
Referring to tuple elements by index, for example x[0] and x[1], makes it hard for the reader to understand what the elements are. It is clearer to use tuple unpacking to assign meaningful names to the elements. So instead of:

value_count = sorted(list(self.items()))
return ' '.join( '{}{}'.format(x[0], LetterCounter.int_to_superscript(x[1])) for x in value_count )


write something like:

return " ".join("{}{}".format(key, str(count).translate(SUPERSCRIPT_TRANS))
                for key, count in sorted(self.items())


or, if you are happy to use formatted string literals:

return " ".join(f"{key}{str(count).translate(SUPERSCRIPT_TRANS)}"
                for key, count in sorted(self.items()))



2. Revised code

# -*- coding: utf-8 -*-

from collections import Counter

# Code point mapping from digits to superscript digits.
SUPERSCRIPT_TRANS = str.maketrans("0123456789", "⁰¹²³⁴⁵⁶⁷⁸⁹")

class LetterCounter(Counter):
    """Subclass of Counter with readable string conversion using sorted
    ordering of keys and superscript digits for counts.

    &gt;&gt;&gt; print(LetterCounter("HELLOWORLD"))
    D¹ E¹ H¹ L³ O² R¹ W¹

    """
    def __str__(self):
        return " ".join(f"{key}{str(count).translate(SUPERSCRIPT_TRANS)}"
                        for key, count in sorted(self.items()))


3. Answers to questions


If you want a mapping with sorted views of its keys and items, then you need the sortedcontainers package, which has the SortedItemsView that you are looking for. (The package has no SortedCounter, but it is not difficult to write one by subclassing SortedDict.)
It is rarely a good idea to leave dead code (like the subscripts in your example). The problem is that dead code does not get tested, and so as the live code changes it is easy to forget to make corresponding changes to the dead code, so that when you come to try to resurrect the dead code you find that it is broken.
The pickling protocol uses its own special methods like __getstate__, not __repr__.
There are situations in which it's useful for eval(repr(o)) to return an object similar to o, but otherwise you are free to redefine __repr__ however you like.