
<p class="has-drop-cap wp-block-paragraph">Årets Breeders Crown-finaler för treåringar håller hög klass och blir välbetalda revanschmöten från kullens största lopp, Svenskt Travkriterium och Svenskt Trav-Oaks.<br>Från Kriteriet finns nämligen ettan, trean, fyran, sexan och ytterligare fyra finalister bland de tolv i finalen. På stosidan kvalade ettan, tvåan, trean, femman och en finalist in till BC-finalen.</p>



<p class="wp-block-paragraph">Snacka om finaler av högsta klass!</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/10/12nadadevicut1-617x333.jpg" alt="" class="wp-image-908224"/><figcaption class="wp-element-caption">Mattias Djuse-tränade Nanda Devi Cut och Mats E Djuse vid Kriteriesegern. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Kriteriet togs hem av Mattias Djuse-tränade <strong>Nanda Devi Cut</strong> (e. Maharajah), som satte världsrekordet 1.11,9a/2.640 meter vid segern i försöket och följde upp det på bästa sätt i finalen. I Breeders Crown-semifinalen kunde han inte riktigt fånga in ledande <strong>Kodiak Zet</strong> (e. Father Patrick) som tvåa.<br><strong>Kriteriehästar i Breeders Crown-finalen: </strong>1) Nando Devi Cut, 3) Intro, 4) Neutron Star, 6) Mister Nabab. Opl/dg: No Hitter, Kodiak Zet, Vancouver Tile, Steady Spender.</p>



<h2 class="wp-block-heading">Startlista – treåriga hingstar och valacker</h2>



<p class="wp-block-paragraph"><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li><strong>Com Best</strong> (e. Tactical Landing) – Magnus A Djuse (Mattias Djuse)</li>



<li><strong>No Hitter</strong> (e. Gimpanzee) – Carl Johan Jepson (Sabine Kagebrant)</li>



<li><strong>Kodiak Zet</strong> (e. Father Patrick) – Örjan Kihlström (Daniel Redén)</li>



<li><strong>Steady Spender</strong> (e. Readly Express) – Ole Johan Östre (Eric Martinsson)</li>



<li><strong>City Slicker</strong> (e. King City) – Johan Untersteiner (Joakim Elfving)</li>



<li><strong>Nanda Devi Cut</strong> (e. Maharajah) – Mats E Djuse (Mattias Djuse)</li>



<li><strong>Vancouver Tile</strong> (e. Walner) – Björn Goop</li>



<li><strong>Neutron Star</strong> (e. Gimpanzee) – Claes Sjöström</li>



<li><strong>In The Wind Gar</strong> (e. Captain Corey) – Robin Bakker (Paul Hagoort)</li>



<li><strong>Intro</strong> (e. Readly Express) – Frdrik Plassen (Björn Röcklinger)</li>



<li><strong>Mister Nabab</strong> (e. Mister J.P.) – Daniel Wäjersten</li>



<li><strong>In Fine Fettle</strong> (e. From Above) – Marcus Lilius (Daniel Wäjersten)</li>
</ol>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/10/10zeebreeze2-617x333.jpg" alt="" class="wp-image-908207"/><figcaption class="wp-element-caption">Daniel Wäjersten-tränade Zeebreeze och Mats E Djuse. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Daniel Wäjersten-tränade <strong>Zeebreeze</strong> (e. Gimpanzee) fick sitt stora genombrott när hon vann Oaks och mer än fördubblade sin prissumma tillsammans med Mats E Djuse. Zeebreeze satte huvudet först i en tät slutstrid.<br><strong>Oakshästar i Breeders Crown-finalen: </strong>1) Zeebreeze, 2) Global Halo, 3) I See Tail Lights, 5) Thai Medina. Dg: Miss Brighton.</p>



<h2 class="wp-block-heading">Startlista – treåriga ston</h2>



<p class="wp-block-paragraph"><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li><strong>Thai Medina</strong> (e. Face Time Bourbon) – Björn Goop</li>



<li><strong>I See Tail Lights</strong> (e. Maharajah) – Markus B Svedberg</li>



<li><strong>Zeebreeze</strong> (e. Gimpanzee) – Mats E Djuse (Daniel Wäjersten)</li>



<li><strong>Grace In Heaven</strong>  (e. Chapter Seven) – Daniel Wäjersten</li>



<li><strong>Mellby Orkide</strong> (e. Calgary Games) – Magnus A Djuse (Daniel Redén)</li>



<li><strong>Wendy</strong> (e. Readly Express) – Mika Forss (Holger Ehlert)</li>



<li><strong>Hawthorne Effect</strong> (e. Face Time Bourbon) – Victor Rosleff (Alessandro Gocciadoro)</li>



<li><strong>Arizona Trot</strong> (e. Power) – Åke Lindblom</li>



<li><strong>Miss Brighton</strong> (e. Calgary Games) – Örjan Kihlström (Daniel Redén)</li>



<li><strong>Cruiser</strong> (e. Calgary Games) – Johan Untersteiner</li>



<li><strong>Giulia Barosso</strong> (e. Bar Hopping) – Stefan Persson (Johan Untersteiner)</li>



<li><strong>Global Halo</strong> (e. Ready Cash) – Tyler Mifsud (Joakim Lövgren)</li>
</ol>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/09/6thaimedina-617x333.jpg" alt="" class="wp-image-903073"/><figcaption class="wp-element-caption">Thai Medina vinner för Björn Goop. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Treåringarna som kvalat in till BC-final har redan sprungit ihop över 36 miljoner kronor tillsammans, eller 1.500.396 kronor i snitt!<br>Hingstarna/valackerna har tjänat lite med med 19.423.920 kronor (1.618.660 kronor i snitt), medan stonas siffra är 16.585.595 kronor (1.382.133 kronor i snitt).</p>



<p class="wp-block-paragraph">Det finns fler storloppsmeriter vid sidan om Kriteriet och Oaks i finalfältet. Bland hingstarna/valackerna tog <strong>Steady Spender</strong> hem korta E3 och <strong>City Slicker</strong> vann Svampen som tvååring. <strong>Neutron Star</strong> var tvåa i Svensk Uppfödningslöpning, medan <strong>In The Wind Gar</strong> tagit silver i både Breeders Course över medeldistans och långa E3.</p>



<p class="wp-block-paragraph">Treåringsdrottningen inför Oaks var <strong>Thai Medina</strong> som vann dubbla Grupp I-finaler i E3-serien, där hon var bäst både i långa och korta upplagan. <strong>Cruiser</strong> var obesegrad tvååringsdrottning med seger i Breeders Course som tyngsta titel.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/09/10kodiakzet-617x333.jpg" alt="" class="wp-image-903093"/><figcaption class="wp-element-caption">Kodiak Zet och Örjan Kihlström håller säkert undan från spets. Foto; Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Det har körts 138 Breeders Crown-finaler sedan de första vinnarna <strong>Noble Tilly</strong> (e. Tibur) och <strong>Miss Hambleton</strong> (e. Super Mon) korades i treåringsklasserna på Axevalla 1991. Inför lördagens finaler är Daniel Redén den dominerande tränaren. Förra året tog han en dubbelseger när <strong>La Yuca</strong> (e. Face Time Bourbon) och <strong>Perfect Chest</strong> (e. Perfect Spirit) vann varsin final.</p>



<p class="wp-block-paragraph">I år har han kvalat in fem hästar till final, varav tre på treåringssidan i form av stona <strong>Mellby Orkide</strong> och <strong>Miss Brighton</strong>, samt valacken <strong>Kodiak Zet</strong>. Bland de fyraåriga stona försvaras stallets färger av <strong>Jiovanha Falkone</strong> och <strong>Jacqueline Zet</strong>.</p>



<p class="wp-block-paragraph">Flest hästar i BC-finalerna har Redéns utmanare om svenska tränarchampionatet, Daniel Wäjersten. Han har kvalat in sju hästar till storloppen och jagar sin andra finalaseger. Den första kom med <strong>Bullet The Bluesky</strong> (e. Readly Express) för treåriga hingstar och valacker för två år sedan.</p>



<p class="wp-block-paragraph"><strong>Tränarligan i Breeders Crown:</strong></p>



<ul class="wp-block-list">
<li>Daniel Redén – 12</li>



<li>Robert Bergh – 8</li>



<li>Timo Nurmos – 8</li>



<li>Stig H Johansson – 7</li>



<li>Roger Walmann – 7</li>



<li>Stefan Hultman – 6</li>



<li>Stefan Melander – 6</li>



<li>Björn Goop – 5</li>



<li>Svante Båth – 4</li>



<li>Olle Goop – 4</li>



<li>Åke Svanstedt – 4</li>



<li>Johan Untersteiner – 4</li>



<li>Petri Puro – 3</li>



<li>Jörgen Westholm – 3</li>
</ul>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">Breeders Crown ingår i premiechansen och hästar som ingår där tävlar om 50 procent extra i prispengar. Det gäller 22 av de 24 hästarna i treåringarnas final.<br>De som står utanför är italienske valacken <strong>In The Wind Gar</strong> (e. Captain Corey) och USA-födda stoet <strong>Grace In Heaven</strong> (e. Chapter Seven).</p>



<p class="wp-block-paragraph"><strong>Priser för premiechansade hästar:</strong><br>1.200.000-600.000-300.000-144.000-96.000-60.000 kr</p>



<p class="wp-block-paragraph"><strong>Priser för icke premiechansade och utländska hästar: </strong><br>800.000-400.000-200.000-96.000-64.000-40.000 kr</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/11/6graceinheaven-617x333.jpg" alt="" class="wp-image-917292"/><figcaption class="wp-element-caption">Grace In Heaven och Daniel Wäjersten. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">En av 3.146 ettåringar som sålts för 100.000 dollar eller mer som ettåringar på auktion i USA dyker upp i stonas final. Daniel Wäjersten-tränade <strong>Grace In Heaven</strong> (e. Chapter Seven) växte upp på andra sidan Atlanten och bjöds ut i Lexington som ettåring, där Reijo Liljendahl hade högsta budet.</p>



<p class="wp-block-paragraph">Grace In Heaven tävlade som tvååring i USA i Marcus Melanders regi och tjänade drygt 550.000 kronor på sju starter. Inför treåringssäsongen kom hos till Sverige och Daniel Wäjersten med Emida Holding AB, Limhamn, som ägare och som USA-född har Breeders Crown varit säsongens stora mål. Grace In Heaven har vunnit två försök under säsongen innan hon även tog hem semifinalen.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">Med inköpspriset 100.000 dollar var Grace In Heaven dyrast av de treåriga finalisterna som ettåring, men fler dyringar har nått till finalen. <strong>Guilia Barosso</strong> (e. Bar Hopping) ropades in för 800.000 kronor av norrmannen Kjell Magne Andersson och hon har travat ihop nästan halva köpesumman så här långt.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/08/cruiserjustart-617x333.jpg" alt="" class="wp-image-881840"/><figcaption class="wp-element-caption">Cruiser och Johan Untersteiner. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Andersen äger två finalister bland de treåriga stona. <strong>Cruiser</strong> (e. Calgary Games) var utbjuden som ettåring, men ropades åter för 80.000 kronor. På tävlingsbanan var hon svensk regent som tvååring som obesegrad i fyra starter. I år har hon varit finalist i två Grupp I-lopp och laddas för en tredje final. </p>



<p class="wp-block-paragraph">På hingstsidan är auktionsdyringarna <strong>Vancouver Tile</strong> (e. Walner) och <strong>Intro</strong> (e. Readly Express), som kostade 775.000 respektive 650.000 kronor. Intro har lyckats bäst hittills med tredjeplatsen i Svenskt Travkriterium som tyngsta merit.</p>



<p class="wp-block-paragraph"><strong>Auktionspriser – treåriga ston: </strong></p>



<ul class="wp-block-list">
<li><strong>Grace In Heaven</strong> – Lexington Selected Yearling Sales – 100.000 dollar</li>



<li><strong>Guilia Barosso</strong> – Solvalla Yearling Sale – 800.000 kr</li>



<li><strong>Thai Medina</strong> – Solvalla Yearling Sale – 300.000 kr</li>



<li><strong>I See Tail Lights </strong>– Menhammar Online Sales – 120.000 kr</li>
</ul>



<p class="wp-block-paragraph"><strong>Fotnot: </strong>Cruiser ropades åter för 80.000 kronor på Solvalla Yearling Sale.</p>



<p class="wp-block-paragraph"><strong>Treåriga hingstar/valacker:</strong></p>



<ul class="wp-block-list">
<li><strong>Vancouver Tile</strong> – Elitauktionen – 775.000 kr</li>



<li><strong>Intro</strong> – Menhammar Online Sales – 650.000 kr</li>



<li><strong>Neutron Star</strong> – Solvalla Yearling Sale – 480.000 kr</li>



<li><strong>In The Wind Gar</strong> – ITS Yearling Sale – 24.000 euro</li>



<li><strong>In Fine Fettle</strong> – Menhammar Online Sales – 150.000 kr</li>
</ul>



<p class="wp-block-paragraph"><strong>Fotnot:</strong> Steady Spender ropades åter för 160.000 kronor på Åby Yearling Sale.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/09/8iseetaillights-617x333.jpg" alt="" class="wp-image-903083"/><figcaption class="wp-element-caption">I See Tail Lights och Markus B Svedberg. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Menhammar Stuteri delar ledningen i uppfödarligan med Boko Stables och Ekeröstuteriet har dubbla chanser att gå upp ensamt i topp med en finalist vardera i treåringarnas finaler, semifinalvinnaren <strong>I See Tail Lights</strong> (e. Maharajah) och <strong>In Fine Fettle</strong> (e. From Above).</p>



<p class="wp-block-paragraph">Tio av 24 treåriga finalister ägs fortsatt helt av sin uppfödare, fem hingstar/valacker och lika många ston.</p>



<p class="wp-block-paragraph"><strong>Uppfödare med två eller fler vinnare: </strong></p>



<p class="wp-block-paragraph"><strong>Boko Stables (6)</strong></p>



<ul class="wp-block-list">
<li>2002 – Rae Boko</li>



<li>2006 – Vala Boko</li>



<li>2008 – Yield Boko</li>



<li>2009 – Yield Boko</li>



<li>2016 – Grant Boko</li>



<li>2022 – Lara Boko</li>
</ul>



<p class="wp-block-paragraph"><strong>Menhammar Stuteri (6)</strong></p>



<ul class="wp-block-list">
<li>2001 – Energetic</li>



<li>2002 – From Above</li>



<li>2010 – One Too Many</li>



<li>2011 – Perfectly Enough</li>



<li>2017 – Unrestricted </li>



<li>2019 – Brother Bill</li>
</ul>



<p class="wp-block-paragraph"><strong>Brixton Medical AB (3)</strong></p>



<ul class="wp-block-list">
<li>2015 – Trinity Zet</li>



<li>2021 – Francesco Zet</li>



<li>2022 – Francesco Zet</li>
</ul>



<p class="wp-block-paragraph"><strong>Brodda Stuteri (3)</strong></p>



<ul class="wp-block-list">
<li>2001 – Yatzy Brodda</li>



<li>2022 – Dancer Brodde</li>



<li>2024 – Daim Brodda</li>
</ul>



<p class="wp-block-paragraph"><strong>Broline International (3)</strong></p>



<ul class="wp-block-list">
<li>2009 – Ibiza Broline</li>



<li>2015 – Pacific Broline</li>



<li>2016 – Rhyme Broline</li>
</ul>



<p class="wp-block-paragraph"><strong>Erikssunds Trotting (3)</strong></p>



<ul class="wp-block-list">
<li>1995 – Imposant Sund</li>



<li>2005 – Triton Sund</li>



<li>2016 – In Toto Sund</li>
</ul>



<p class="wp-block-paragraph"><strong>Ulrik &#038; Ylva Lindh (3)</strong></p>



<ul class="wp-block-list">
<li>1997 – Simb Capi </li>



<li>1999 – Simb Zipper</li>



<li>2001 – Simb Moonrunner</li>
</ul>



<p class="wp-block-paragraph"><strong>Am Bloodstock AB (2)</strong></p>



<ul class="wp-block-list">
<li>2013 – Amazon Am</li>



<li>2019 – Forfantone Am</li>
</ul>



<p class="wp-block-paragraph"><strong>Carl Henrik Brandel (2)</strong></p>



<ul class="wp-block-list">
<li>1992 – Ina Scot</li>



<li>1993 – Ina Scot</li>
</ul>



<p class="wp-block-paragraph"><strong>Easy KB, Uppsala (2)</strong></p>



<ul class="wp-block-list">
<li>2004 – Camilla Highness</li>



<li>2005 – Fama Currit</li>
</ul>



<p class="wp-block-paragraph"><strong>Thomas Lind-Holm, Danmark (2)</strong></p>



<ul class="wp-block-list">
<li>2019 – Ganga Bae</li>



<li>2021 – Glamorous Rain</li>
</ul>



<p class="wp-block-paragraph"><strong>A &#038; H K Karlsson och Jörgen Westholm (2)</strong></p>



<ul class="wp-block-list">
<li>2022 – Queen Belina</li>



<li>2023 – Queen Belina</li>
</ul>



<p class="wp-block-paragraph"><strong>Ove Konradsson med flera (2)</strong></p>



<ul class="wp-block-list">
<li>2018 – Conrads Rödluva</li>



<li>2019 – Conrads Rödluva</li>
</ul>



<p class="wp-block-paragraph"><strong>Allevamento Kronos, Italien (2)</strong></p>



<ul class="wp-block-list">
<li>2015 – Treasure Kronos</li>



<li>2106 – Target Kronos</li>
</ul>



<p class="wp-block-paragraph"><strong>AB Lavec (2)</strong></p>



<ul class="wp-block-list">
<li>1994 – Tiba Lavec</li>



<li>2005 – Kung Lavec</li>
</ul>



<p class="wp-block-paragraph"><strong>A-L Lorentzon &#038; J-E Magnusson (2)</strong></p>



<ul class="wp-block-list">
<li>1995 – Sissela Ås </li>



<li>2005 – Joy Ås</li>
</ul>



<p class="wp-block-paragraph"><strong>Stefan Melander &#038; Ingemar Löfberg (2)</strong></p>



<ul class="wp-block-list">
<li>2010 – Aisle Stand</li>



<li>2013 – Digital Ink</li>
</ul>



<p class="wp-block-paragraph"><strong>Oskari Mäenpää, Finland (2)</strong></p>



<ul class="wp-block-list">
<li>2007 – Sahara Dynamite</li>



<li>2008 – Sahara Dynamite</li>
</ul>



<p class="wp-block-paragraph"><strong>Norra Näs Stuteri AB (2)</strong></p>



<ul class="wp-block-list">
<li>1993 – Lovely Godiva</li>



<li>1994 – Lovely Godiva</li>
</ul>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/10/nohitterpris-617x397.jpg" alt="" class="wp-image-906944"/><figcaption class="wp-element-caption">No Hitter. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<h2 class="wp-block-heading">Fakta Breeders Crown treåriga hingstar/valacker</h2>



<p class="wp-block-paragraph"><em>Häst – Uppfödare – Ägare – Skötare</em></p>



<ol class="wp-block-list">
<li><strong>Com Best</strong> – Väsby Häst AB, Stockholm – Väsby Häst AB, Stockholm – Camilla Svahn</li>



<li><strong>No Hitter</strong> – Courant Inc, USA – Stall Courant AB, Heby – Erik Cederlund</li>



<li><strong>Kodiak Zet</strong> – Stall Zet AB (Daniel Redén), Örsundsbro – Stall Zet (Daniel Redén) – Michaela Magnusson</li>



<li><strong>Steady Spender</strong> – Lars &#038; Anna Katarina Melin – LIlla Edets Maskinuthyrning AB – Malin Martinsson</li>



<li><strong>City Slicker</strong> – AB Svensk Reklamfinans, Halmstad – SRF Stable – My Hedberg</li>



<li><strong>Nanda Devi Cut</strong> – S.A.R.L. Ecurie de Windcut, Frankrike – S.A.R.L. Ecurie de Windcut, Frankrike – Victor Remneby</li>



<li><strong>Vancouver Tile</strong> – Vestmarka AB, Vinninga – Karin Walter-Mommert, Tyskland – Stig Rune Sele</li>



<li><strong>Neutron Star</strong> – Stall Courant, Heby – Uppsala Handelshus AB, M fl – Sara Norrström</li>



<li><strong>In The Wind Gar</strong> – Allev Garigliano S.R.L., Italien – Dragon Trotters B.V., Nederländerna – Kim Hagoort</li>



<li><strong>Intro</strong> – Annemanna AB, Ekerö – Hypnotic AB, Järfälla – Linda Bergkvist</li>



<li><strong>Mister Nabab</strong> – Haras de la Source et des Chenes, Frankrike – Ecurie Jean-Pierre Barjon, Frankrike – Charlotte Andersson</li>



<li><strong>In Fine Fettle</strong> – Menhammar Stuteri AB, Ekerö – Tibor Caro, Njurunda – Johanna Nordin</li>
</ol>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/10/10zeebreeze4-617x333.jpg" alt="" class="wp-image-908209"/><figcaption class="wp-element-caption">Daniel Wäjersten-tränade Zeebreeze och Mats E Djuse. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<h2 class="wp-block-heading">Fakta Breeders Crown treåriga ston</h2>



<p class="wp-block-paragraph"><em>Häst – Uppfödare – Ägare – Skötare</em></p>



<ol class="wp-block-list">
<li><strong>Thai Medina</strong> – Thaihester Egersund A/S, Danmark – B.S.Stable AB, Vimmerby – Hanna Lindkvist</li>



<li><strong>I See Tail Lights</strong> – Menhammar Stuteri AB, Ekerö – Olof Brodin (Chartering) AB – Ninni Gardelin</li>



<li><strong>Zeebreeze</strong> – AB Svensk Reklamfinans, Halmstad – SRF Stable – Johanna Persson</li>



<li><strong>Grace In Heaven</strong> – Kenneth Kjellgren, Österskär – Emida Holding AB, m fl – Lova Gruvris</li>



<li><strong>Mellby Orkide</strong> – Mellby Gård AB, Malmö – Mellby Gård AB, Malmö – Lucas Andersson</li>



<li><strong>Wendy</strong> – Günter Herz, Tyskland – Günter Herz, Tyskland – Nicole Neumann</li>



<li><strong>Hawthorne Effect</strong> – Glas &#038; Bågar i Hälsingland AB, Bollnäs – Stall Oculus – Anu Niskanen</li>



<li><strong>Arizona Trot</strong> – Ove Karlsson, Fjugesta – Åke Lindblom Stable AB, m fl – Matilda Legneroth</li>



<li><strong>Miss Brighton</strong> – Onkel Invest Oy, Finland – Onkel Invest Oy, Finland – Aleksi Flink</li>



<li><strong>Cruiser</strong> – Andersen Racing Stable AB, Stockholm – Andersen Racing Stable AB, Stockholm – Jenny Nilsson</li>



<li><strong>Giulia Barosso</strong> – Ronald F Nooteboom, Nederländerna – Andersen Racing Stable AB, Stockholm – Jenny Nilsson</li>



<li><strong>Global Halo</strong> – Global Farm AB, Nacka – Karin Walter-Mommert, Tyskland – Gerald Vella</li>
</ol>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/10/cityslickerok-617x333.jpg" alt="" class="wp-image-911252"/><figcaption class="wp-element-caption">Joakim Elfvings City Slicker och Örjan Kihlström. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Stall Zet är framgångsrikaste hästägare i svenska Breeders Crown-historien med nio vinster totalt. Den senaste kom förra året genom <strong>Perfect Chest</strong> (e. Perfect Spirit) i finalen för de treåriga hingstarna och valackerna. I år har stallet en ny segerchans i samma klass genom semifinalvinnaren <strong>Kodiak Zet</strong> (e. Father Patrick).<br>Dessutom har Stall Zet fyraåriga stona <strong>Jiovanha Falkone</strong> (e. Don Fanucci Zet) och <strong>Jacqueline Zet</strong> (e. Googoo Gaagaa).</p>



<p class="wp-block-paragraph">Av ägarna med två eller fler finalsegrar kan även Lennart Ågrens SRF Stable utöka segerskörden. Två starka kort finns på treåringssidan i Oaksvinnaren <strong>Zeebreeze</strong> (e. Gimpanzee) och <strong>City Slicker</strong> (e. King City).</p>



<p class="wp-block-paragraph"><strong>Hästägare med två eller fler vinnare: </strong></p>



<p class="wp-block-paragraph"><strong>Stall Zet (9)</strong></p>



<ul class="wp-block-list">
<li>2015 – Trinity Zet</li>



<li>2016 – In Toto Sund</li>



<li>2018 – Conrads Rödluva</li>



<li>2019 – Conrads Rödluva</li>



<li>2020 – Mister Hercules</li>



<li>2021 – Francesco Zet</li>



<li>2021 – Glamorous Rain</li>



<li>2022 – Francesco Zet </li>



<li>2025 – Perfect Chest</li>
</ul>



<p class="wp-block-paragraph"><strong>Stall T.Z. &#038; Lövis (5)</strong></p>



<ul class="wp-block-list">
<li>1998 – Rydens Randy</li>



<li>2001 – Yatzy Brodda</li>



<li>2010 – Aisle Stand</li>



<li>2013 – Digital Ink</li>



<li>2015 – Nuncio</li>
</ul>



<p class="wp-block-paragraph"><strong>TNT Stable (3)</strong></p>



<ul class="wp-block-list">
<li>2007 – Sahara Dynamite</li>



<li>2008 – Sahara Dynamite</li>



<li>2009 – Red Hot Dynamite</li>
</ul>



<p class="wp-block-paragraph"><strong>Anders van Dapperen AB (2)</strong></p>



<ul class="wp-block-list">
<li>2022 – Queen Belina</li>



<li>2023 – Queen Belina</li>
</ul>



<p class="wp-block-paragraph"><strong>Ina-Q AB &#038; Kjell P Dahlström (2)</strong></p>



<ul class="wp-block-list">
<li>1992 – Ina Scot</li>



<li>1993 – Ina Scot</li>
</ul>



<p class="wp-block-paragraph"><strong>In the Zone AB, Bromma (2)</strong></p>



<ul class="wp-block-list">
<li>2011 – Kadett C.D. </li>



<li>2013 – Amazon Am</li>
</ul>



<p class="wp-block-paragraph"><strong>Srf Stable (2)</strong></p>



<ul class="wp-block-list">
<li>2019 – Forfantone Am</li>



<li>2021 – Fifty Cent Piece</li>
</ul>



<p class="wp-block-paragraph"><strong>Stall Tilly (2)</strong></p>



<ul class="wp-block-list">
<li>1991 – Noble Tilly</li>



<li>2014 – Noble Tilly</li>
</ul>



<p class="wp-block-paragraph"><strong>Stens Trot AB, Nacka Strand (2)</strong></p>



<ul class="wp-block-list">
<li>2022 – Dancer Brodde</li>



<li>2023 – Stens Rubin</li>
</ul>



<p class="wp-block-paragraph"><strong>Team Cololoco HB, Göteborg (2)</strong></p>



<ul class="wp-block-list">
<li>1993 – Lovely Godiva</li>



<li>1994 – Lovely Godiva</li>
</ul>



<p class="wp-block-paragraph"><strong>W. Horse AB, Enskede (2)</strong></p>



<ul class="wp-block-list">
<li>2009 – Yield Boko</li>



<li>2010 – Yield Boko</li>
</ul>



<figure class="wp-block-embed is-type-wp-embed is-provider-sulkysport wp-block-embed-sulkysport"><div class="wp-block-embed__wrapper">
<blockquote class="wp-embedded-content" data-secret="Y7PgVHa5rE"><a href="https://sulkysport.se/bc-kung-utan-finalister/">BC-kung utan finalister</a></blockquote><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”BC-kung utan finalister” – Sulkysport" src="https://sulkysport.se/bc-kung-utan-finalister/embed/#?secret=I9ISRLMhEs#?secret=Y7PgVHa5rE" data-secret="Y7PgVHa5rE" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe>
</div></figure>
