
<p class="has-drop-cap">Stona slår hingstarna och valackerna på fingrarna när det gäller insprungna pengar hittills i karriären av BC-finalisterna. 16.784.775 kronor har stona dragit in, vilket ger 1.398.731 kronor i snitt per finalist. Killarna har å sin sida sprungit in 14.487.952 kronor, eller 1.207.329 kronor i snitt.<br>Hingstarna och valackerna har gjort några fler starter än stona – 149 mot 142 – och vunnit fler lopp: 57-44.</p>



<p>Här är finalfälten för treåringarna, där hingstarna/valackernas final körs som lopp 6 (kl. 16.42) och stona gör upp i lopp 10 (kl. 18.20) på lördag på Sundbyholm över distansen 2.140 meter autostart.</p>



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



<p><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li>August Zonett (e. Pojke Kronos) – Mats E Djuse (Daniel Wäjersten)</li>



<li>Coin Boy L.A. (e. Flocki d’Aurcy) – Magnus A Djuse (Hanna Olofsson)</li>



<li>Bullet the Bluesky (e. Readly Express) – Daniel Wäjersten</li>



<li>Far Wise As (e. Face Time Bourbon) – Johan Untersteiner (Jerry Riordan)</li>



<li>Fly Equos Jet (e. Readly Express) – Robin Bakker (Paul Hagoort)</li>



<li>Lando Mearas (e. Walner) – Erik Adielsson (Daniel Wäjersten)</li>



<li>Googoo Casino (e. Googoo Gaagaa) – Robert Bergh</li>



<li>Currency Artist (e. Royalty For Life) – Ulf Ohlsson (Ville Karhulahti)</li>



<li>Preacherman (e. Father Patrick) – Stefan Persson (Ola Samuelsson)</li>



<li>Izod Zet (e. Propulsion) – Örjan kihlström (Daniel Redén)</li>



<li>Conrads Leonard (e. Bar Hopping) – André Eklundh</li>



<li>Fahrenheit (e. Maharajah) – Björn Goop (Mattias Djuse)</li>
</ol>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/11/5j.h.ellen-617x333.jpg" alt="" class="wp-image-655184"/><figcaption class="wp-element-caption">J.H.Ellen spurtar till vinst för Björn Goop. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



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



<p><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li>S.G. Empress (e. Readly Express) – Örjan Kihlström (Roger Walmann)</li>



<li>J.H. Ellen (e. Winter Harbor) – Björn Goop</li>



<li>La Yuca (e. Face Time Bourbon) – Magnus A Djuse (Daniel Redén)</li>



<li>Vivillion (e. Propulsion) – Ulf Ohlsson (Daniel Wäjersten)</li>



<li>Screen Time Limit (e. Face Time Bourbon) – Daniel Wäjersten</li>



<li>Elegance Silvio (e. Maharajah) – Johan Untersteiner</li>



<li>Lilium Sisu (e. Face Time Bourbon) – Mika Forss (Petri Salmela)</li>



<li>Lovely Rita (e. Greenshoe) – Erik Adielsson (Markus B Svedberg)</li>



<li>Oriana Boko (e. Father Patrick) – Micha Brouwer (Danny Brouwer)</li>



<li>Great Pride (e. Maharajah) – Claes Sjöström (Roger Walmann)</li>



<li>Beedrill (e. Muscle Hill) – Per Linderoth (Daniel Wäjersten)</li>



<li>Kinky Rain (e. Muscle Hill) – Peter Untersteiner (Johan Untersteiner)</li>
</ol>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/10/bullettheblueskydw241012o-1-617x411.jpg" alt="" class="wp-image-645905"/><figcaption class="wp-element-caption">Daniel Wäjersten jublar efter segern i Svenskt Travkriterium med Bullet The Bluesky. Foto: Stefan Melander/stalltz.se</figcaption></figure>



<p class="has-drop-cap">Tättrion i Svenskt Travkriterium är också vinstrikast när treåringssäsongen går in i elfte timmen och sista storloppsfinalen avgörs på lördagen. Vinnaren <strong>Bullet the Bluesky</strong> toppar listan före en annan Readly Express-son, <strong>Phantom Express</strong>, som slutade trea i Kriteriet.</p>



<p>Den som sprängde sig in mellan dessa på Solvalla var <strong>Walmann</strong>. Både Walmann och Phantom Express missar dock BC-finalen, då de slutade femma i sina semifinaler.</p>



<p><strong>Vinstrikaste treåringar 2024 – hingstar/valacker:</strong><br><em>Häst (far) – Resultat – Prispengar</em></p>



<ol class="wp-block-list">
<li>Bullet The Bluesky (e. Readly Express) – 12 st: 8-2-0 – 5.278.000 kr</li>



<li>Phantom Express (e. Ready Express) – 12 st: 7-2-2 – 3.120.000 kr</li>



<li>Walmann (e. Walner) – 8 st: 3-3-0 – 2.405.000 kr</li>



<li>Dream Mine (e. Maharajah) – 7 st: 4-1-1 – 2.286.500 kr</li>



<li>Lando Mearas (e. Walner) – 14 st: 6-1-3 – 1.659.500 kr</li>
</ol>



<p><em>Statistiken gäller svenskfödda och svensktränade treåringar.</em></p>



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



<p class="has-drop-cap">Åtta svenskfödda ston har sprungit in över en miljon kronor hittills i år och i topp finns årets Oaksvinnare <strong>Vivillion</strong>, som förutom tre miljoner på ett bräde i Oaks dragit in ytterligare en halv miljon kronor.<br>Daniel Wäjersten tränar Vivillion, som kom från Reijo Liljendahls stall i somras. Detsamma gäller även tvåan <strong>Screen Time Limit</strong>, som nått 2,6 miljoner trots att hon gick lottlös från Paksfinalen där det blev tidig galopp.</p>



<p><strong>Vinstrikaste treåringar 2024 – ston:</strong><br><em>Häst (far) – Resultat – Prispengar</em></p>



<ol class="wp-block-list">
<li>Vivillion (e. Propulsion) – 11 st: 4-3-0 – 3.509.500 kr</li>



<li>Screen Time Limit (e. Face Time Bourbon) – 12 st: 5-4-0 – 2.641.000 kr</li>



<li>S.G.Empress (e. Ready Express) – 12 st: 9-1-0 – 2.376.000 kr</li>



<li>Olivia Bros (e. Muscle Mass) – 20 st: 3-3-6 – 2.195.500 kr</li>



<li>Lovebird Journey (e. Chapter Seven) – 6 st: 3-3-0 – 1.780.000 kr</li>
</ol>



<p><em>Statistiken gäller svenskfödda och svensktränade treåringar.</em></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/11/9s.g.empress-617x333.jpg" alt="" class="wp-image-655217"/><figcaption class="wp-element-caption">S.G.Empress vinner BC-semi för Örjan Kihlström. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Hur har det då gått för lördagens finalister i kullens storloppsfinaler så här långt? Båda vinnarna av kullens största lopp i Sverige finns med i form av Kriterievinnaren <strong>Bullet The Bluesky</strong> och Oaksettan <strong>Vivillion</strong>, men det finns ytterligare vinnare som tagit sjusiffriga segercheckar.</p>



<p><strong>Screen Time Limit</strong> tog hem långa E3 i somras och fick två miljoner kronor som premiechansad. Italienske <strong>Far Wise As</strong> och svenska S.G.Empress vann varsin final i korta E3 i augusti, medan <strong>Oriana Boko</strong> segrade i Breeders Course över medeldistans på Elitloppsdagen.</p>



<p><strong>Hingstar/valacker som vunnit lopp med 200.000 kronor eller mer i förstapris:</strong></p>



<ul class="wp-block-list">
<li>August Zonett – Sommarfavoriten (200.000 kr), BC-semifinal (200.000 kr)</li>



<li>Coin Boy L.A. – BC-semifinal (200.000 kr)</li>



<li>Bullet The Bluesky – Svenskt Travkriterium (4.000.000 kr), Sweden International Yearling Sales Auktionslopp (300.000 kr), försök till Kriteriet (200.000 kr), BC-semifinal (200.000 kr)</li>



<li>Far Wise As – Korta E3 (1.000.000 kr), korta Breeders Course (500.000 kr)</li>



<li>Lando Mearas – Margaretas Tidiga Unghästserie (300.000 kr), Norrlands Elitserie (200.000 kr), försök till Kriteriet (200.000 kr)</li>



<li>Izod Zet – Kriteriet consolation (200.000 kr)</li>
</ul>



<p><strong>Ston som vunnit lopp med 200.000 kronor eller mer i förstapris:</strong></p>



<ul class="wp-block-list">
<li>S.G.Empress – Korta E3 (1.000.000 kr), Guldstoet (350.000 kr), Margaretas Tidiga Unghästserie (225.000 kr, dött lopp), BC-semifinal (200.000 kr), Höstfavoriten (200.000 kr)</li>



<li>J.H.Ellen – BC-semifinal (200.000 kr)</li>



<li>La Yuca – Breeders Course Criteriumday-races (250.000 kr), BC-semifinal (200.000 kr)</li>



<li>Vivillion – Svenskt Trav-Oaks (3.000.000 kr)</li>



<li>Screen Time Limit – Långa E3 (2.000.000 kr)</li>



<li>Lilium Sisu – Norskt Stokriterium (636.545 kr). Norskt Oaks (293.790 kr)</li>



<li>Oriana Boko – långa Breeders Course (1.000.000 kr)</li>
</ul>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/08/farwiseasjum240817adamstromstalltz-617x410.jpg" alt="" class="wp-image-622722"/><figcaption class="wp-element-caption">Jerry Riordan-tränade Far Wise As och Johan Untersteiner vann korta E3-finalen. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap">Hela nio (!) av tolv hästar i finalen för treåriga ston ägs fortsatt av sin uppfödare, där bröderna Hannu och Mikko Laakkonen (Ravitalli H Laakkonen Oy &#038; ML Stable Oy) står för tre av dem – precis som i finalen av Svenskt Trav-Oaks.</p>



<p>Ett av stona i finalen har bytt ägare i auktionsringen. <strong>Great Pride</strong> ropades in på Menhammar Online Sales sommaren 2022 för en miljon kronor.</p>



<p>På hingst- och valacksidan ser det helt annorlunda ut. Där var sju av tolv hästar utbjudna på auktion som ettåringar. Två av dem – <strong>Googoo Casino</strong> och <strong>Conrads Leonard</strong> – ströks dock från Kriterieauktionen respektive Solvalla Yearling Sale.<br>Av de som såldes kostade betalades allra mest för mångmiljonären <strong>Vivid Wise As</strong> lillebror <strong>Far Wise As</strong>. På italienska ITS-auktionen såldes hästen för en bra bit över två miljoner kronor (210.000 euro). På samma auktion såldes <strong>Fly Equos Jet</strong> för 38.000 euro.</p>



<p>På nordiska mark kostade <strong>Preacherman</strong> allra mest när Olof Brodin (Chartering) AB, Sollentuna, betalade 700.000 danska kronor – över en miljon i svensk valuta – på danska Derbyauktionen.<br>I Sverige var <strong>Bullet The Bluesky</strong> dyrast när han gick för 850.000 kronor på Solvalla Yearling Sales. <strong>Currency Artist</strong> såldes för 130.000 kronor på Kriterieauktionen.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/10/coinboyl.a.heat-617x333.jpg" alt="" class="wp-image-642831"/><figcaption class="wp-element-caption">Hanna Olofssons  treåring Coin Boy L.A. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Breeders Crown-finalerna ingår i premiechansen för kullen född 2021 och ger dubbla prispengarna för hästar som är prisplacerade.</p>



<p>Detta gäller 20 av 24 treåringar, medan fyra treåringar inte tävlar om dubbla pengarna. Det handlar om <strong>Far Wise As</strong> och <strong>Fly Equos Jet</strong>, som är födda i Italien, stoet <strong>Lilium Sisu</strong> som är norskfödd, och Hanna Olofsson-tränade <strong>Coin Boy L.A</strong>.<br>Den sistnämnde galopperade i premielopp i april som tvååring, men genomförde godkänt premielopp i augusti och ägaren Stall Lag kunde kvittera ut 20.000 kronor.</p>



<p>Prisskala premiechansade hästar (halva summorna för övriga hästar):<br>1.600.000-800.000-400.000-192.000-128.000-80.000 kronor</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/07/landomearas2-617x333.jpg" alt="" class="wp-image-604276"/><figcaption class="wp-element-caption">Lando Mearas. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p><strong>Här är skötarna bakom finalisterna för treåriga hingstar/valacker:</strong></p>



<ol class="wp-block-list">
<li>August Zonett – Carola Eklund</li>



<li>Coin Boy L.A. – Anna Karlsson</li>



<li>Bullet the Bluesky – Carola Eklund </li>



<li>Far Wise As – Veera Venälänen</li>



<li>Fly Equos Jet – Demi Veenstra</li>



<li>Lando Mearas – Marja Ahonen</li>



<li>Googoo Casino – Therese Hallin</li>



<li>Currency Artist – Jonna Roos</li>



<li>Preacherman – Kathrine Henriksson</li>



<li>Izod Zet – Lina Pergenius</li>



<li>Conrads Leonard – Constanza Flores</li>



<li>Fahrenheit – Viktor Remneby</li>
</ol>



<p><strong>Här är skötarna bakom finalisterna för treåriga ston:</strong></p>



<ol class="wp-block-list">
<li>S.G. Empress – Malin Boman-Friberg</li>



<li>J.H. Ellen – Hillevi Frohm</li>



<li>La Yuca – Caroline Närström </li>



<li>Vivillion – Ebba Karbelius</li>



<li>Screen Time Limit – Marja Ahonen</li>



<li>Elegance Silvio – Jeanette Klasson</li>



<li>Lilium Sisu – Ira-Maria Lahti</li>



<li>Lovely Rita – Elina Johansson</li>



<li>Oriana Boko – Luca van Toor</li>



<li>Great Pride – Malin Boman-Friberg</li>



<li>Beedrill – Marja Ahonen</li>



<li>Kinky Rain – Jeanette Klasson</li>
</ol>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/09/8screentimelimit-617x333.jpg" alt="" class="wp-image-640231"/><figcaption class="wp-element-caption">Screen Time Limit och Daniel Wäjersten håller knappt undan för Great Pride i Oakskval. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Boko Stables och Menhammar Stuteri – sida vid sida i uppfödarligan med sex segrar vardera i Breeders Crown-historien. Boko Stables har ett hopp i lördagens finaler, nämligen stoet <strong>Oriana Boko</strong> (e. Father Patrick), som tävlat framgångsrikt i år i regi Danny Brouwer.</p>



<p>I finalen ställs hon bland annat mot <strong>Great Pride</strong> (e. Maharajah), som är deluppfödd av Menhammar Stuteri tillsammans med Yvonnick Garandeau. <br>Garandeau är uppfödare till <strong>Reality Pride</strong> (e. From Above), som köptes av Menhammar som fölsto och har lämnat Derbyvinnaren och avelshingsten <strong>Who’s Who</strong> (e. Maharajah).</p>



<p>Menhammar Stuteri har en egen uppfödning i finalerna, fyraårige valacken <strong>Flotilla</strong> (e. Readly Express).</p>



<h2 class="wp-block-heading">Uppfödare med två eller fler vinnare</h2>



<p><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><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><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><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><strong>Erikssunds</strong> <strong>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><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><strong>Am Bloodstock AB (2)</strong></p>



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



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



<p><strong>Carl Henrik Brandel (2)</strong></p>



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



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



<p><strong>Easy KB, Uppsala (2)</strong></p>



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



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



<p><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><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><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><strong>Allevamento Kronos, Italien (2)</strong></p>



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



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



<p><strong>AB Lavec (2)</strong></p>



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



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



<p><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><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><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><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">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/11/10augustzonett-617x333.jpg" alt="" class="wp-image-655227"/><figcaption class="wp-element-caption">August Zonett vinner för Daniel Wäjersten. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p><strong>Här är ägarna och uppfödarna bakom finalisterna för treåriga hingstar/valacker:</strong><br><em>Finalist – Uppfödare – Hästägare</em></p>



<ol class="wp-block-list">
<li>August Zonett – Tomwik AB – Stall Zonett</li>



<li>Coin Boy L.A. – Lasses Hästsport AB – Stall Lag</li>



<li>Bullet the Bluesky – Top of Europe Management AB &#038; A Djuve – Stall SoFo</li>



<li>Far Wise As – Allev. Della Serenissima Ss, m f – B. Racing Team AB &#038; Andersen Racing St. AB</li>



<li>Fly Equos Jet – Az. Agr. Toniatti Giacometti – Luctijn Holding B.V.</li>



<li>Lando Mearas – Snogarps Gård AB – Kjell Johansson</li>



<li>Googoo Casino – Rolf Hagert – Steve Tiselius Åkeri AB, m f</li>



<li>Currency Artist – Int. Hacienda Oy &#038; Juha Saarijärvi – Fjellström Häst AB, m f</li>



<li>Preacherman – Panamera Racing/Jens Glud Hansen – Olof Brodin (Chartering) AB</li>



<li>Izod Zet – Brixton Medical AB – Stall Zet</li>



<li>Conrads Leonard – Ove Conradsson – Manatar AB &#038; Mats B Hansson Förv. AB</li>



<li>Fahrenheit – J.G. Byggservice AB – J.G. Byggservice AB</li>
</ol>



<p><strong>Här är ägarna och uppfödarna bakom finalisterna för treåriga ston:</strong><br><em>Finalist – Uppfödare – Hästägare</em></p>



<ol class="wp-block-list">
<li>S.G. Empress – Skärgården Stuteri AB – Skärgården Stuteri AB</li>



<li>J.H. Ellen – Johanna, Jaana &#038; Janika Häggman – Gnosjö Personaluthyrning AB</li>



<li>La Yuca – Eagles Rising AB – Eagles Rising AB</li>



<li>Vivillion – Ravitalli H Laakkonen Oy &#038; ML Stable Oy – Ravitalli H Laakkonen Oy &#038; ML Stable Oy</li>



<li>Screen Time Limit – Ravitalli H Laakkonen Oy &#038; ML Stable Oy – Ravitalli H Laakkonen Oy &#038; ML Stable Oy</li>



<li>Elegance Silvio – Stall Silvio AB – Stall Silvio AB</li>



<li>Lilium Sisu – Sisyfos Breeders AB – Lilium Oy</li>



<li>Lovely Rita – Am Bloodstock AB – Stall Courant AB</li>



<li>Oriana Boko – Boko Stables Holland BV – Gerrits Recycling Group BV</li>



<li>Great Pride – Menhammar Stuteri &#038; Y Garandeau – Marylebone AB </li>



<li>Beedrill – Ravitalli H Laakkonen Oy &#038; ML Stable Oy – Ravitalli H Laakkonen Oy &#038; ML Stable Oy</li>



<li>Kinky Rain – Thomas Lind-Holm – Thomas Lind-Holm</li>
</ol>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/10/izodzetokm241009adamstromstalltz-617x401.jpg" alt="" class="wp-image-644832"/><figcaption class="wp-element-caption">Izod Zet och Örjan Kihlström vinner Kriterium Consolation. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap">Stall Zet dominerar bland hästägarna i Breeders Crown och bland treåringarna har stallet ytterligare en finalist i hingsten <strong>Izod Zet</strong> (e. Propulsion). Denne inledde med fyra raka segrar, men missade Kriteriet efter tredjeplatsen i försöket. Hästen tog liten revansch genom att vinna Kriteriet Consolation och nu får hans chansen att jaga karriärens största prischeck hittills.</p>



<p>Om han vinner gör han storasyster <strong>In Toto Sund</strong> (e. Ken Warkentin) sällskap som vinnare av Breeders Crown. In Toto Sund vann finalen för fyraåriga ston 2016.</p>



<h2 class="wp-block-heading">Hästägare med två eller fler vinnare</h2>



<p><strong>Stall Zet (8)</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>
</ul>



<p><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><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><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><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><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><strong>Srf Stable (2)</strong></p>



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



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



<p><strong>Stall Tilly (2)</strong></p>



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



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



<p><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><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><strong>W. Horse AB, Enskede (2)</strong></p>



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



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