diff -r 42f3be6cf29e Lib/pickle.py
--- a/Lib/pickle.py	Tue May 12 00:15:05 2015 -0400
+++ b/Lib/pickle.py	Tue May 12 12:07:23 2015 +0300
@@ -691,7 +691,28 @@ class _Pickler:
         self.memoize(obj)
     dispatch[bytes] = save_bytes
 
+    def save_oldstr(self, obj):
+        if self.bin:
+            n = len(obj)
+            if n < 256:
+                self.write(SHORT_BINSTRING + pack("<B", n) + obj)
+            else:
+                self.write(BINSTRING + pack("<i", n) + obj)
+        else:
+            r = ascii(obj)
+            assert r[0] == 'b'
+            self.write(STRING + r[1:].encode('ascii') + b'\n')
+
     def save_str(self, obj):
+        if self.fix_imports and self.proto < 3 and len(obj) <= 0x7fffffff:
+            try:
+                encoded = obj.encode('ascii')
+            except UnicodeEncodeError:
+                pass
+            else:
+                self.save_oldstr(encoded)
+                self.memoize(obj)
+                return
         if self.bin:
             encoded = obj.encode('utf-8', 'surrogatepass')
             n = len(encoded)
diff -r 42f3be6cf29e Lib/test/pickletester.py
--- a/Lib/test/pickletester.py	Tue May 12 00:15:05 2015 -0400
+++ b/Lib/test/pickletester.py	Tue May 12 12:07:23 2015 +0300
@@ -1181,6 +1181,8 @@ class AbstractPickleTests(unittest.TestC
                     self.assertIn(b'\nL64206', s)  # LONG
                 elif proto < 2:
                     self.assertIn(b'M\xce\xfa', s)  # BININT2
+                elif proto < 3:
+                    self.assertIn(b'U\x04FACE', s)  # BINUNICODE
                 elif proto < 4:
                     self.assertIn(b'X\x04\x00\x00\x00FACE', s)  # BINUNICODE
                 else:
diff -r 42f3be6cf29e Modules/_pickle.c
--- a/Modules/_pickle.c	Tue May 12 00:15:05 2015 -0400
+++ b/Modules/_pickle.c	Tue May 12 12:07:23 2015 +0300
@@ -2224,9 +2224,76 @@ write_unicode_binary(PicklerObject *self
 }
 
 static int
+save_oldstr(PicklerObject *self, PyObject *obj)
+{
+    Py_ssize_t size;
+    const char *data;
+    PyObject *repr = NULL;
+
+    assert(PyUnicode_Check(obj));
+    assert(PyUnicode_IS_ASCII(obj));
+    if (!self->bin) {
+        const char string_op = STRING;
+
+        if (!(repr = PyObject_ASCII(obj)))
+            return -1;
+        assert(PyUnicode_Check(repr));
+        assert(PyUnicode_IS_ASCII(repr));
+
+        data = PyUnicode_AsUTF8AndSize(repr, &size);
+        if (data == NULL)
+            goto err;
+        if (_Pickler_Write(self, &string_op, 1) < 0)
+            goto err;
+        if (_Pickler_Write(self, data, size) < 0)
+            goto err;
+        if (_Pickler_Write(self, "\n", 1) < 0)
+            goto err;
+
+        Py_DECREF(repr);
+    }
+    else {
+        Py_ssize_t len;
+        char header[5];
+
+        data = PyUnicode_AsUTF8AndSize(obj, &size);
+        if (size < 256) {
+            header[0] = SHORT_BINSTRING;
+            header[1] = size;
+            len = 2;
+        }
+        else {
+            assert(size <= 0x7fffffffL);
+            header[0] = BINSTRING;
+            header[1] = (unsigned char)(size & 0xff);
+            header[2] = (unsigned char)((size >> 8) & 0xff);
+            header[3] = (unsigned char)((size >> 16) & 0xff);
+            header[4] = (unsigned char)((size >> 24) & 0xff);
+            len = 5;
+        }
+
+        if (_Pickler_Write(self, header, len) < 0)
+            return -1;
+        if (_Pickler_Write(self, data, size) < 0)
+            return -1;
+    }
+
+    return 0;
+
+  err:
+    Py_XDECREF(repr);
+    return -1;
+}
+
+static int
 save_unicode(PicklerObject *self, PyObject *obj)
 {
-    if (self->bin) {
+    if (self->fix_imports && self->proto < 3 &&
+        PyUnicode_IS_ASCII(obj) && PyUnicode_GET_LENGTH(obj) <= 0x7fffffffL) {
+        if (save_oldstr(self, obj) < 0)
+            return -1;
+    }
+    else if (self->bin) {
         if (write_unicode_binary(self, obj) < 0)
             return -1;
     }