Unfurling-Safe Quine

Question

Write a proper quine containing at least one newline/linefeed whose every unfurling is either itself a proper quine or outputs the original quine. Your answer can mix and match outputting itself and outputting the original quine.

Unfurlings

Unfurlings consist of:

1. Appending spaces to make the input a rectangle.
2. Taking all lines above the bottom one and rotating them a quarter-turn clockwise about the lower-right corner so that the right edge is on the same level as the bottom edge.
3. Repeat step (2) until the string is a single line to find all unfurlings.

For example, the first unfurling of

GFE
HID
ABC

is

   HG
   IF
ABCDE

and the rest are

   HG
   IF
ABCDE

     IH
ABCDEFG

       I
ABCDEFGH

ABCDEFGHI

This process is automated with this program adapted from Emigna's answer here,where each step of unfurling in the output is delimited by a dashed line.

Example

For example, if you have a program

K
AB

(no trailing spaces)

then it must be a proper quine and print itself('K\nAB', where \n represents a linefeed/newline). According to the output of the unfurling program, we see that the next step in unfurling is

  K
AB 

(note trailing space)

This must either print itself(' K\nAB ') or the original program ('K\nAB'). The next step in the unfurling is

AB K

This must either print itself ('AB K'), or the original program('K\nAB').

The byte-count of this program is 4 (K, \n, A, B).

Score

This is code-golf, so the shortest answer in bytes wins. Standard loopholes apply, as usual.

Answer 1

Python 3, 48 bytes

_='\n_=%r;print(_%%_,end="")';print(_%_,end="")

Try it online!

I mean, it works :p

Answer 2

Python 3, 42 bytes

_='\n_=%r;print(end=_%%_)';print(end=_%_)

Try it online!

Answer 3

Ruby, 32 bytes

_="\n_=%p;print _%%_";print _%_

Try it online!

Answer 4

CJam, 11 bytes

OK, let's go with the obvious trivial solution. At least it's shorter than the Python and Ruby solutions that use the same trick.

{N\"_~"}_~

This code begins with a newline, which is ignored by the CJam interpreter. All the actual code is on the last line, which is not changed by the unfurling process. The extra spaces and newlines introduced by unfurling the empty first line are also ignored by the interpreter.

Otherwise this is just a trivial tweak of a (or perhaps the) standard CJam quine. {N\"_~"} defines a code block, _~ makes a copy of it and executes it. Inside the code block, N\ pushes a newline before the copy of the block on the stack and "_~" pushes the string _~ after it. When the program ends, the CJam interpreter automatically prints everything on the stack, i.e. the newline, the code block and the _~.

Try it online!