V, 28 (or 16?) Latin 1 bytes (35 UTF-8 bytes)

ñéÑ~"qpx!!xxd -b
ÎdW54|D
Íßó

Try it online!

Hexdump (in Latin 1):

00000000: f1e9 d17e 2271 7078 2121 7878 6420 2d62 ...~"qpx!!xxd -b
00000010: 0ace 6457 3534 7c44 0acd dff3 ..dW54|D....

Output (binary representation of the same code in UTF-8, not Latin 1):

110000111011000111000011101010011100001110010001011111100010001001110001011100000111100000100001001000010111100001111000011001000010000000101101011000100000110111000011100011100110010001010111001101010011010001111100010001000000110111000011100011011100001110011111110000111011001100001010

Explanation:

ñéÑ~"qpx " Standard quine. Anything after this doesn't affect the
 " program's 'quine-ness' unless it modifies text in the buffer
 !!xxd -b " Run xxd in binary mode on the text
Î " On every line...
 dW " delete a WORD
 54| " Go to the 54'th character on this line
 D " And delete everything after the cursor
Í " Remove on every line...
 ó " Any whitespace
 ß " Including newlines

Or...

V, 16 bytes

ñéÑ~"qpx!!xxd -b

Try it online!

Output:

00000000: 11000011 10110001 11000011 10101001 11000011 10010001 ......
00000006: 01111110 00100010 01110001 01110000 01111000 00100001 ~"qpx!
0000000c: 00100001 01111000 01111000 01100100 00100000 00101101 !xxd -
00000012: 01100010 00001010 b.

OP said:

The output may be in any convenient format.

This outputs in a much more convenient format for V :P (but I'm not sure if that's stretching the rules)

CJam, 20 bytes

s"_~"+i2b8Te[%_~

Try it online!

Surprised to see CJam winning! _{we'll see how long that lasts...}

05AB1E, 105 bytes

0"D34çýÇbεDg•Xó•18в@ƶà©i7j0ìëR6ôRíć7®-jšTìJ1®<×ì]ð0:J"D34çýÇbεDg•Xó•18в@ƶà©i7j0ìëR6ôRíć7®-jšTìJ1®<×ì]ð0:J

05AB1E has no UTF-8 conversion builtins, so I have to do everything manually..

Try it online or verify that it's a quine.

Explanation:

quine-part:

The shortest quine for 05AB1E is this one: 0"D34çý"D34çý (14 bytes) provided by @OliverNi. My answer uses a modified version of that quine by adding at the ... here: 0"D34çý..."D34çý.... A short explanation of this quine:

0 # Push a 0 to the stack (can be any digit)
 "D34çý" # Push the string "D34çý" to the stack
 D # Duplicate this string
 34ç # Push 34 converted to an ASCII character to the stack: '"'
 ý # Join everything on the stack (the 0 and both strings) by '"'
 # (output the result implicitly)

Challenge part:

Now for the challenge part of the code. As I mentioned at the top, 05AB1E has no UTF-8 conversion builtins, so I have to do these things manually. I've used this source as reference on how to do that: Manually converting unicode codepoints into UTF-8 and UTF-16. Here a short summary of that regarding the conversion of Unicode characters to UTF-8:

1. Convert the unicode characters to their unicode values (i.e. "dЖ丽" becomes [100,1046,20029])


2. Convert these unicode values to binary (i.e. [100,1046,20029] becomes ["1100100","10000010110","100111000111101"])


3. Check in which of the following ranges the characters are:
   
   
   1. 
      0x00000000 - 0x0000007F (0-127): 0xxxxxxx
      
   
   
   2. 
      0x00000080 - 0x000007FF (128-2047): 110xxxxx 10xxxxxx
      
   
   
   3. 
      0x00000800 - 0x0000FFFF (2048-65535): 1110xxxx 10xxxxxx 10xxxxxx
      
   
   
   4. 
      0x00010000 - 0x001FFFFF (65536-2097151): 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
      
   
   

There are also ranges for 5 or 6 bytes, but let's leave them out for now.

The character d will be in the first range, so 1 byte in UTF-8; character Ж is in the second range, so 2 bytes in UTF-8; and character 丽 is in the third range, so 3 bytes in UTF-8.

The x in the pattern behind it are filled with the binary of these characters, from right to left. So the d (1100100) with pattern 0xxxxxxx becomes 01100100; the Ж (10000010110) with pattern 110xxxxx 10xxxxxx becomes 11010000 10010110; and the 丽 (100111000111101) with pattern 1110xxxx 10xxxxxx 10xxxxxx becomes 1110x100 10111000 10111101, after which the remaining x are replaced with 0: 11100100 10111000 10111101.

So, that approach I also used in my code. Instead of checking the actual ranges, I just look at the length of the binary and compare it to the amount of x in the patterns however, since that saves a few bytes.

Ç # Convert each character in the string to its unicode value
 b # Convert each value to binary
 ε # Map over these binary strings:
 Dg # Duplicate the string, and get its length
 •Xó• # Push compressed integer 8657
 18в # Converted to Base-18 as list: [1,8,12,17]
 @ # Check for each if the length is >= to this value
 # (1 if truthy; 0 if falsey)
 ƶ # Multiply each by their 1-based index
 à # Pop and get its maximum
 © # Store it in the register (without popping)
 i # If it is exactly 1 (first range):
 7j # Add leading spaces to the binary to make it of length 7
 0ì # And prepend a "0"
 ë # Else (any of the other ranges):
 R # Reverse the binary
 6ô # Split it into parts of size 6
 Rí # Reverse it (and each individual part) back
 ć # Pop, and push the remainder and the head separated to the stack
 7®- # Calculate 7 minus the value from the register
 j # Add leading spaces to the head binary to make it of that length
 š # Add it at the start of the remainder-list again
 Tì # Prepend "10" before each part
 J # Join the list together
 1®<× # Repeat "1" the value from the register - 1 amount of times
 ì # Prepend that at the front
 ] # Close both the if-else statement and map
 ð0: # Replace all spaces with "0"
 J # And join all modified binary strings together
 # (which is output implicitly - with trailing newline)

See this 05AB1E answer of mine (sections How to compress large integers? and How to compress integer lists?) to understand why •Xó•18в is [1,8,12,17].

JavaScript (Node.js), 60 bytes

-15 bytes from @Neil and @Shaggy

f=_=>[...Buffer(`f=`+f)].map(x=>x.toString(2).padStart(8,0))

Try it online!

Rust, 187 bytes

fn f(o:u8)for c in b"go!g)n;t9(zgns!b!ho!c#%#/huds)(zhg!b_n <27zqshou )#z;19cfn main()f(1);

Try it online!

Perl 6, 46 bytes

<say "<$_>~~.EVAL".ords.fmt("%08b",'')>~~.EVAL

Try it online!

The standard quine with .fmt("%08b",'') formats the list of ordinal values into length 8 binary and joins with an empty string.

Perl 5, 42 bytes

$_=q(say unpack'B*',"$_=q($_);eval");eval

TIO

Java 10, 339 308 265 227 225 186 184 bytes

v->var s="v->var s=%c%s%1$c;return 0+new java.math.BigInteger(s.format(s,34,s).getBytes()).toString(2);";return 0+new java.math.BigInteger(s.format(s,34,s).getBytes()).toString(2);

-8 bytes thanks to @NahuelFouilleul removing the unnecessary &255 (and an additional -35 for bringing to my attention that the full program specs of the challenge had been revoked and a function is allowed now as well..)

-41 bytes thanks to @OlivierGrégoire.

Try it online.

Explanation:

quine-part:

• 
  var s contains the unformatted source code String


• 
  %s is used to put this String into itself with s.format(...)
  


• 
  %c, %1$c and 34 are used to format the double-quotes (")


• 
  s.format(s,34,s) puts it all together

Challenge part:

v-> // Method with empty unused parameter and String return-type
 var s="..."; // Unformatted source code String
 return 0+ // Return, with a leading "0":
 new java.math.BigInteger( // A BigInteger of:
 s.format(s,34,s) // The actual source code String
 .getBytes()) // Converted to a list of bytes (UTF-8 by default)
 .toString(2); // And convert this BigInteger to a binary-String 

Python 2, 68 67 bytes

_="print''.join(bin(256|ord(i))[3:]for i in'_=%r;exec _'%_)";exec _

Try it online!

A modification of this answer

-1 bytes by removing the space after 'in' (thanks @mdahmoune)

R, 138 114 bytes

x=function()rev(rawToBits(rev(charToRaw(sprintf("x=%s;x()",gsub("\s","",paste(deparse(x),collapse="")))))));x()

Try it online!

Uses R’s ability to deparse functions to their character representation. The revs are needed because rawToBits puts the least significant bit first. as.integer is needed because otherwise the bits are displayed with a leading zero.

Edited once I realised that any convenient output was allowed. Also was out by one on original byte count.

C# (Visual C# Interactive Compiler), 221 bytes

var s="var s=010;Write(string.Concat(string.Format(s,(char)34,s).Select(z=>Convert.ToString(z,2).PadLeft(8,'0'))));";Write(string.Concat(string.Format(s,(char)34,s).Select(z=>Convert.ToString(z,2).PadLeft(8,'0'))));

Try it online!

C# (Visual C# Interactive Compiler) with flag /u:System.String, 193 bytes

var s="var s=010;Write(Concat(Format(s,(char)34,s).Select(z=>Convert.ToString(z,2).PadLeft(8,'0'))));";Write(Concat(Format(s,(char)34,s).Select(z=>Convert.ToString(z,2).PadLeft(8,'0'))));

Try it online!

Bash + GNU tools, 48 bytes

trap -- 'trap|xxd -b|cut -b9-64|tr -dc 01' EXIT

TIO

Shell script, 42 bytes

#!/bin/sh
xxd -b<"$0"|cut -b9-64|tr -dc 01

Two additional bytes may be removed (the quote marks) if the filename doesn't contain spaces or special characters.