Just use a proper DOM parser and be done with it. You don't have to work extra hard to produce an inferior regex solution to a problem that has already been solved robustly and that has a solution with very low barrier to entry.

#!/usr/bin/env perl

use strict;
use warnings;
use Mojo::DOM;
use Mojo::Util 'trim';

my $html = do {local $/ = undef; <DATA>};

my $dom = Mojo::DOM->new($html);

foreach my $div ($dom->find('div')->each) {

    printf "Found div with id [%s], class [%s] and content [%s]\n",
        $div->{'id'}       // '',
        $div->{'class'}    // '',
        trim($div->content // '');

}


__DATA__
<div id="roguebin-response-35911" class="bin-response"></div>
<div id="othertest-1" class="foobar">content here
</div>
[download]

Notice the second div spans more than one line. This is a problem you don't have to solve yourself. It may be relatively trivial to do so, but this is only the first of many problems people encounter using regexes to treat HTML as regular text when it's not.

Here's the output:

Found div with id [roguebin-response-35911], class [bin-response] and 
+content []
Found div with id [othertest-1], class [foobar] and content [content h
+ere]
[download]

Installing Mojolicious will set you back two megabytes of storage once installed, and will also provide you with a UserAgent, a web framework, and a testing tool. You can install it using cpanm, or by downloading the tarball from Mojolicious, unpacking it, and running perl Makefile.PL && make && make test && make install. In containers, Carton is a nice way of specifying the dependency. Install time takes about a minute, and has no non-core Perl requirements, although you do need to be on a version of Perl less than six years old.

If you want to trigger some behavior based on whether the div is on a different line, just search $div->content for \n. But unless you're writing some sort of tool for cleaning up HTML it's usually best to write code that doesn't care about the formatting of the HTML.

While I entirely agree with davido's exhortation to use a proper parser for HTML, I will answer your question because it is (in this one instance) fairly trivial. The capture group does not match because you have used the asterisk as the quantifier after it. This matches zero or more instances, and zero is, of course, the shortest.

Here's your code with a few small tweaks and the key change of using the plus as the quantifier:

#!/usr/bin/perl
use strict;
use warnings;

my $line = '<div id="roguebin-response-35911" class="bin-response"></d
+iv>';

if ($line =~ /<div.+?(<\/div)+/)
{
    print "line matched\n";

    if (defined $1)
    {
        print "right after match, 1 is defined\n";
    }
}
[download]

Similarly you don't really need a quantifier at all here because there is only one closing div in the string and one is the default quantity of anything in a regex.

I've used print instead of printf because you are not doing any format conversion. I've removed some unnecessary brackets and have used single quotes to delimit the initial string so the internal double quotes no longer need escaping (and you aren't interpolating in this string either).

But seriously, use a parser.

The problem with using the + quantifier is that the entire regex will not match a line that has an opening <div tag but no closing </div tag on the same line. For example, your modification will not match the following:

my $line = "<div id=\"roguebin-response-35911\" class=\"bin-response\"
+>";
[download]

I was hoping to write a single regex that will handle both cases, i.e. an opening <div tag with a closing </div tag on the same line, and an opening <div tag with no closing </div tag on the same line. I understand a built in parser would make this task easier, but I would still like to understand how to write a single regex that would capture both of these cases.

Win8 Strawberry 5.8.9.5 (32)  Tue 12/22/2020 16:43:09
C:\@Work\Perl\monks
>perl -Mstrict -Mwarnings
for my $line (
    '<div id="foo-bar-321" class="bin-boff"></div>',
    '<div id="foo-bar-321" class="bin-boff"> </div>',
    '<div id="foo-bar-321" class="bin-boff">foo</div>',
    '<div id="foo-bar-321" class="bin-boff"> foo </div>',
    '<div id="foo-bar-321" class="bin-boff">',
    '<div id="foo-bar-321" class="bin-boff">  ',
    '<div id="foo-bar-321" class="bin-boff">foo',
    '<div id="foo-bar-321" class="bin-boff"> foo',
    ) {

    if ($line =~ m{ <div (?: (?! </div) .)+ (</div)? }xms) {
        print "line matched \n  '$&' \n";
        if (defined $1) {
            print "  right after match, \$1 is defined '$1' \n";
            }
        }

    }
^Z
line matched
  '<div id="foo-bar-321" class="bin-boff"></div'
  right after match, $1 is defined '</div'
line matched
  '<div id="foo-bar-321" class="bin-boff"> </div'
  right after match, $1 is defined '</div'
line matched
  '<div id="foo-bar-321" class="bin-boff">foo</div'
  right after match, $1 is defined '</div'
line matched
  '<div id="foo-bar-321" class="bin-boff"> foo </div'
  right after match, $1 is defined '</div'
line matched
  '<div id="foo-bar-321" class="bin-boff">'
line matched
  '<div id="foo-bar-321" class="bin-boff">  '
line matched
  '<div id="foo-bar-321" class="bin-boff">foo'
line matched
  '<div id="foo-bar-321" class="bin-boff"> foo'
[download]

---

Give a man a fish:  <%-{-{-{-<

#!/usr/bin/perl
use strict;
use feature qw{ say };
use warnings;

for my $line ('<div id="roguebin-response-35911" class="bin-response">
+</div>',
              '<div id="roguebin-response-35911" class="bin-response">
+'
) {
    if ($line =~ m{<div.+(</div)|<div.+}) {
        say "line matched";
        if (defined $1) {
            say "right after match, 1 is defined: $1";
        }
    }
}
[download]

As a general thing any .[*+] match is suspect. An often useful trick is to use a negative lookahead match to nibble one character at a time:

my $str = "Send it to bob.sled\@gmail.com. Don't send it to ski.guy\@y
+ahoo.com.";

print "$1\n" if $str =~ /(( (?!\.\s). )+ \.\s)/x;
[download]

Prints:

Send it to bob.sled@gmail.com.
[download]