
<p class="has-drop-cap">När Erik Adielsson kör ut på banan med storfavoriten och 19-faldiga miljonärskan <strong>Joviality</strong> (e. Chapter Seven i årets upplaga av Stochampionatet gör han det som en av fem kuskar i fältet som vet hur man vinner loppet.</p>



<p>För Eriks del kom enda segern hittills redan 2001 bakom Tommy Hanné-tränade <strong>Volita du Ling</strong> (e. Super Arnie). Toppstoet vann 20 av 42 starter och tjänade över tre miljoner kronor. I Stochampionatet var Robert Berghs kulldrottning <strong>Hilda Zonett</strong> (e. Spotlite Lobell) stor favorit, men högsommaren var aldrig Hildas årstid och inför loppet hade Erik fått körorder från Hanné: ”Släpp inte till Hilda!”<br>Erik följde instruktionerna och Volita du Ling ledde från start till mål och Hilda Zonett slutade trea från dödens. Hilda tog istället en av sina stora segrar en dryg månad senare – i Svenskt Travderby!</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/jovialityeam230621adamstromstalltz-617x409.jpg" alt="" class="wp-image-461193"/><figcaption class="wp-element-caption">Joviality vid seger för Erik Adielsson i Prix Diana Zet. Foto Adam Ström/stalltz.se</figcaption></figure>



<p>Samma startspår väntar med Joviality som inleder från innern bakom bilen och nog drömmer Adielsson om repris 22 år efter sin första och enda Stochampionatsvinst.</p>



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



<h2 class="wp-block-heading">Startlista Stochampionatet, Axevalla</h2>



<p><em>2.640 meter autostart:</em><br>Namn (far) – Kusk (tränare)</p>



<ol class="wp-block-list">
<li>Joviality (e. Chapter Seven) – Erik Adielsson (Sabine Kagebrant)</li>



<li>Bold Face (e. Mosaique Face) – Adrian Kolgjini</li>



<li>Joy Sisu (e. Brillantissime) – Mika Forss (Petri Salmela)</li>



<li>Queen Belina (e. Nuncio) – Örjan Kihlström (Jörgen Westholm)</li>



<li>Aurelia Express (e. Readly Express) – Mats E Djuse (Timo Nurmos)</li>



<li>Miking (e. Maharajah) – Thomas Uhrberg</li>



<li>Global Dancer (e. Carat Williams) – Björn Goop (Fredrik Wallin)</li>



<li>Xerava C.D. (e. Uncle Lasse) – Per Lennartsson (Hans R Strömberg)</li>



<li>Jennifer Sisu (e. Propulsion) – Magnus A Djuse (Timo Nurmos)</li>



<li>Jurista (e. Ready Cash) – Daniel Wäjersten</li>



<li>O’Mara Zon (e. Maharajah) – Ulf Ohlsson (Daniel Wäjersten)</li>



<li>Mary Ann Lane (e. Orlando Vici) – Johan Untersteiner</li>
</ol>



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



<p class="has-drop-cap">6år i rad har Stochampionatet ingått i premiechansen med chans till dubbla prischeckar och det har 29 av 36 prisplacerade hästägare dragit nytta av. Den enda bland topp sex 2017-2022 som inte varit premiechansad är 2017 års trea <strong>Schatzi Fayline</strong> (e. Maharajah).</p>



<p>I årets finalfält är samtliga tolv ston med i premiechansen vilket ger följande prisskala i finalen:<br>2.400.000 – 1.200.000 – 600.000 – 288.000 – 192.000 – 120.000 kronor.</p>



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



<p class="has-drop-cap">Örjan Kihlström är kungen bland kuskarna i Stochampionatet. När han vann med Daniel Redéns <strong>Honey Mearas</strong> (e. Readly Express) för två år sedan var det hans åttonde seger i Axevallas storlopp. Fler än någon annan. <br><strong>Här är hans övriga vinnare: </strong>Royaling (e. Royal Prestige) 1992, Pine Dust (e. Pine Chip) 2002, Giant Diablo (e. Supergill) 2004, Lie Detector (e. Varenne) 2008, Calamara Donna (e. Pine Chip) 2009, Tamla Celeber (e. Cantab Hall) 2011 och Diana Zet (e. Hard Livin) 2020.</p>



<p>Med åtta kusksegrar i Stochampionatshistorien klev han förbi Stig H Johansson, som triumferat sju gånger. Stig H vann med sex egentränade ston Holly Rodney (e. Captain Rodney) 1977, Gina Roy (e. Speedy Min) 1988, Queen L. (e. Crowntron) 1990, Bowls Lady (e. Super Bowl) 1991, Fiona San (e. Tibur) 1995 och Je T’aime Dream (e. Sugarcane Hanover) 2003, samt lånestyrningen Varia (e. Frosted Yankee) 1981.</p>



<p>I årets final kör Kihlström Jörgen Westholm-tränade <strong>Queen Belina</strong> (e. Nuncio).</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/07/carolinasmysticpris-617x333.jpg" alt="" class="wp-image-189982"/><figcaption class="wp-element-caption">Björn och Olle Goop flankerar Carolinas Mystic efter Stochampionatet 1997. Foto Stefan Melander/Stalltz.se</figcaption></figure>



<p class="has-drop-cap">Björn Goop debuterade med dunder och brak i Stochampionatet 1997, då han 20 år gammal segrade med pappa Olles <strong>Carolinas Mystic</strong> (e. Karate Chop). Det var Björns första Grupp I-seger som kusk och har följts av många, många stora triumfer.<br>I Axevallas stora slag vann han även i andra försöket med Lars-Eric Magnussons <strong>Sweet As Candy</strong> (e. Smasher) 2000 och för fem år sedan spräckte Björn även nollan som tränade när <strong>Mellby Free</strong> (e. Muscle Hill) vann.</p>



<p>Under 2000-talet har Björn har varit representerad i Stochampionatet varje år – antingen som kusk (alla år utom 2020) eller tränare – och den 24-åriga sviten kan ingen annan kusk utmana när Björn nu kör FredrikWallin-tränade <strong>Global Dancer</strong> (e. Carat Williams).</p>



<p>Förutom Adielsson, Kihlström och Goop har även Johan Untersteiner (<strong>Neona Princess</strong> 2014) och Daniel Wäjersten (<strong>Great Skills</strong> 2022) vunnit Stochampionatet tidigare av årets kuskar.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/07/greatskillsdwm220725adamstromstalltz-617x396.jpeg" alt="" class="wp-image-331941"/><figcaption class="wp-element-caption">Stochampionatsvinnaren 2022: Great Skills. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p class="has-drop-cap">Nionde gången gillt blev det för Ready Cash i Stochampionatet förra året. Han hade tidigare Maja Golds andraplats 2015 som bästa resultat när dottern <strong>Great Skills</strong> slog till i fjolårets upplaga. <br>Elva avelshingstar finns representerade i årets Stochampionat och förutom Ready Cash har även Readly Express lämnat en vinnare tidigare då <strong>Honey Mearas</strong> vann för två år sedan.<br>Sveriges championhingst Maharajah är ensam om att ha två avkommor i finalen.</p>



<h2 class="wp-block-heading">Avelshingstar i Stochampionatet</h2>



<p><em>Namn (finalister 2023) – Tidigare finalister – Resultat</em></p>



<ul class="wp-block-list">
<li>Brillantissime (1) – 1 – Global Collection (5) 2022</li>



<li>Maharajah (2) – 5 – Schatzi Fayline (3) 2017, Mulligan (4) 2017, Vero Spiro (6) 2018, Mahma Lane (0) 2020, Deborah S.H. (6) 2022</li>



<li>Orlando Vici (1) – 2 – Inga In Heaven (0) 2017, Charmante Amok (0) 2018</li>



<li>Readly Express (1) – 3 – <strong>Honey Mearas</strong> (1) 2021, Helluva Am (0) 2021, Tilda Express (0) 2021</li>



<li>Ready Cash (1) – 10 – Maya Gold (2) 2015, Steady Brodda (0) 2015, Caresse (6) 2016, Darling Hornline (0) 2016, Swish Lane (0) 2016, Cash Crowe (0) 2017, Fantasy River (0) 2017, Dibaba (0) 2018, <strong>Great Skills</strong> (1) 2022, Felicia Zet (3) 2022</li>
</ul>



<p><strong>Fotnot: </strong>Carat Williams (1), Chapter Seven (1), Mosaique Face (1), Nuncio (1),  Propulsion (1) och Uncle Lasse (1) har inte haft någon startande avkomma tidigare. Både Nuncios och Propulsions äldsta avkommor är fyra i år.</p>



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



<p class="has-drop-cap">Ingen avelshingst har hittills lämnat tre Stochampionatsvinnare och den statistiken kan inte ändras i år heller. Däremot ståtar fem hingstar med två vinnare vardera och den här kvintetten kan få sällskap av Ready Cash i år genom dottern <strong>Jurista</strong>:</p>



<ul class="wp-block-list">
<li>Earl Bulwark (Gaby Bulwark och Fonians)</li>



<li>Pine Chip (Pine Dust och Calamara Donna)</li>



<li>Quick Pay (Pay The Bill och Kristina Palema)</li>



<li>Super Arnie (Krossed Out och Volita du Ling)</li>



<li>Super Photo Kosmos (Blended Scotch och Galactica)</li>
</ul>



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



<p class="has-drop-cap">Framgångsrikaste uppfödare i Stochampionatshistorien är Menhammar Stuteri. Tre gånger har en häst uppfödd hos Margareta Wallenium-Kleberg vunnit loppet: <strong>Lie Detector</strong> (e. Varenne) 2008, <strong>Ultra Bright</strong> (e. Zola Boko) 2017 och <strong>Activated</strong> (e. Jocose) 2019.</p>



<p>På hästägarsidan firade Stall Palema stora framgångar i Stochampionatet i mitten av 1980-talet. Två av tre upplagor slutade med seger för en av Karl-Erik Benders hästar: 1985 vann <strong>Emelie Palema</strong> (e. Pershing) och två år senare <strong>Kristina Palema</strong> (e. Quick Pay).<br>Stall Zet ståtar också med två segrar: <strong>Diana Zet</strong> (e. Hard Livin) och <strong>Honey Mearas</strong> (e. Readly Express).</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/09/queenbelina-617x333.jpg" alt="" class="wp-image-352679"/><figcaption class="wp-element-caption">Jörgen Westholms Queen Belina vann Breeders Crown-finalen för treåriga ston med Örjan Kihlström i vagnen. Här vann hon semifinalen med tränaren i sulkyn. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">2008 vann <strong>Annicka</strong> (e. Spotlite Lobell) Svenskt Trav-Oaks med tränaren Jörgen Westholm i vagnen. Året efter kvalade hon in till Stochampionatet, där det dock blev galopp i finalen. Ifjol slutade <strong>Ninepoints Candy</strong> (e. S.J.’s Caviar) oplacerad, men nu kan det bli tredje gången gillt för Westholm.</p>



<p>Han har ett starkt kort i Breeders Crown-vinnaren <strong>Queen Belina</strong> (e. Nuncio), som hade en stark fjolårssäsong som även innehöll tredjeplatsen i Oaks som fastlåst. Nu har hon matchats mot Axevallas storlopp och årsdebuterade först i maj och försöket slutade med enkel seger från ledningen.</p>



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



<p class="has-drop-cap">2tränare har dominerat stort i loppets historia. Stig H Johansson toppar med sex triumfer (han körde alla vinnare själv), medan Olle Goop låg bakom fem vinnare, där han tog hjälp av sonen Björn med <strong>Carolinas Mystic</strong> och Jim Frick bakom <strong>Tamila Glory</strong>.</p>



<p><strong>Tränare med två eller fler vinnare i Stochampionatet:</strong></p>



<ul class="wp-block-list">
<li>Stig H Johansson – 6 – Holly Rodney 1977, Gina Roy 1988, Queen L. 1990, Bowls Lady 1991, Fiona San 1995, Je T’aime Dream 2003</li>



<li>Olle Goop – 5 – Sweet Bear 1983, Intact 1986, Tamila Glory 1989, Carolinas Mystic 1997, Princess V. 1999</li>



<li>Roger Walmann – 3 – Giant Diablo 2004, Calamara Donna 2009, Tamla Celeber 2011</li>



<li>Tommy Hanné – 2 – Royaling, Volita du Ling</li>



<li>Stefan Hultman – 2 – Pine Dust 2002, Lie Detector 2008</li>



<li>Sören Nordin – 2 – Gaby Gulwark 1973, Fonians 1975</li>



<li>Bo Näslund – 2 – Kristina Palema 1985, Emelie Palema 1987</li>



<li>Fredrik Persson – 2 – Viola Silas 2010, Ultra Bright 2017</li>



<li>Daniel Redén – 2 – Diana Zet 2020, Honey Mearas 2021</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/2022/10/jennifersisu-617x333.jpg" alt="" class="wp-image-374524"/><figcaption class="wp-element-caption">Timo Nurmos-tränade Jennifer Sisu och Jorma Kontio vid en tidigare seger. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">3tränare i årets finalfält vet hur det känns att vinna Stochampionatet – och för en sitter triumfen färskt i minnet. Daniel Wäjersten hade sin första egentränade häst i Stochampionatet förra året och slog till med seger direkt genom <strong>Great Skills</strong> (e. Ready Cash) på nytt världsrekord. Nu har Wäjersten dubbla chanser att ta andra titeln, då både <strong>Jurista</strong> (e. Ready Cash) och <strong>O’Mara Zon</strong> (e. Maharajah) kvalade in.<br>Förutom Wäjersten har ytterligare två tränare i finalen vunnit loppet tidigare. Timo Nurmos tränade 2007 års vinnare <strong>Vala Boko</strong> (e. Alf Palema) och ställer nu hoppet till två hästar: <strong>Aurelia Express</strong> (e. Readly Express) och <strong>Jennifer Sisu</strong> (e. Propulsion).<br>Fredrik Wallins stjärnsto <strong>Acticated</strong> (e. Jocose) var bäst i finalen för fyra år sedan och nu har Wallin <strong>Global Dancer</strong> (e. Carat Williams).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/09/bonnevillew.i.5-617x333.jpg" alt="" class="wp-image-358766"/><figcaption class="wp-element-caption">Bonneville W.I. vann Svenskt Trav-Oaks före Aurelia Express. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Johan Untersteiner och Adrian Kolgjini har annars tränarsegrar i blodet, då både Lutfi och Peter segrat i slaget på Axevalla med <strong>Simb Capi</strong> (e. Probe) respektive <strong>Neona Princess</strong> (e. Gigant Neo). Johan körde dessutom pappa Peters vinnare Neona Princess, men har själv gått lottlös från två finaler med egentränade ston. Nu har han sin tredje finalist i <strong>Mary Ann Lane</strong> (e. Orlando Vici).<br>Adrian Kolgjini har kört Stochampionatet tre gånger och slutat trea med både pappa Lutfis <strong>Pasithea Face</strong> (e. Muscle Hill) och Daniel Redén-tränade <strong>Award Kronos</strong> (e. Father Patrick). Ifjol var han fyra med sin första egentränade häst, <strong>A Perfect Face</strong> (e. Classic Photo) och i år vann han försök med <strong>Bold Face</strong> (e. Mosaique Face).</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/09/joysisu-617x333.jpg" alt="" class="wp-image-352654"/><figcaption class="wp-element-caption">Joy Sisu spurtar till vinst och plockar ner O&#8217;Mara Zon i Oakskval ifjol. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Bodentränaren Petri Salmela har en hel del starter i svenska årgångslopp på meritlistan, men i Stochampionatet har han bara varit med en gång tidigare, när <strong>Pralini</strong> (e. Firm Tribute) slutade jumbo i 2004 års upplaga.</p>



<p>Nu har han ett vassare kort i försöksvinnaren <strong>Joy Sisu</strong> (e. Brillantissime), som var igång tidigt som tvååring och vann ASVT:s auktionslopp i september i livets tredje start. Ifjol var hon nära att kvala in till både långa och korta E3 (fyra i båda försöken), men fick istället en fullträff i Oakskvalet som hon vann tillsammans med Mika Forss. I finalen knep hon sista slanten som sexa.</p>



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



<p class="has-drop-cap">4av finalisterna var utbjudna på auktion som ettåringar, men alla ropades tillbaka av sina uppfödare. <br><strong>Queen Belina</strong> (e. Nuncio) ropades åter för 250.000 kronor från Kriterieauktionen och det gjordes också <strong>Mary Ann Lane</strong> (e. Orlando Vici) på samma auktion för 140.000 kronor. <strong>Bold Face</strong> (e. Mosaique Face) gick åter på 175.000 kronor på Kolgjini Yearling Sale. <strong>Joy Sisu</strong> (e. Brillantissime) var struken från Elitauktionen.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/09/globaldancermadm220923adamstromstalltz-617x360.jpg" alt="" class="wp-image-358650"/><figcaption class="wp-element-caption">Fredrik Wallin-tränade Global Dancer. Foto Adam Ström/stalltz.se</figcaption></figure>



<p>Fast det finns en auktionsdyring i sällskapet. <strong>Global Dancer</strong> (e. Carat Williams) bytte nämligen ägare i september förra året. Svante Racing KB, Mariestad, bjöd ut det treåriga stoet på Traveras lördagsauktion och Sisyfos Breeders AB, Sigtuna, hade högsta budet: 760.000 kronor!<br>Då var Global Dancer nybakad svensk rekordhållarinna efter att ha vunnit Wallenius Cup för treåriga ston under Jubileumspokalkvällen på Solvalla i mitten av augusti. För sin nya ägare vann stoet både Sikta Mot Stjärnorna och E3-revansch förra året.</p>



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



<p class="has-drop-cap">Thomas Uhrberg körde sitt första Stochampionat redan 1989, då han körde <strong>Cilla Håleryd</strong> (e. Netted) som tränades av popstallspartnern Thomas Nilsson. Någon större lycka blev det inte då stoet galopperade bort sig. Sedan dess har Uhrberg varit med ytterligare nio gånger, varav fem med egentränade ston.<br>Största tränarframgången är fjärdeplatsen med <strong>Mulligan</strong> (e. Maharajah) för sex år sedan, medan Uhrberg som lånekusk var tvåa med Petri Puros <strong>Camilla Highness</strong> (e. Super Arnie) i den vassa upplaga som vanns av <strong>Giant Diablo</strong> (e. Supergill) 2004.</p>



<p>I år är Jägersrotränaren tillbaka med egentränade <strong>Miking</strong> (e. Maharajah), som inför finalen är ”fattigast” av stona med 390.460 kronor på kontot. </p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/07/xeravac.d.hrs-617x333.jpg" alt="" class="wp-image-473070"/><figcaption class="wp-element-caption">Hans R Strömbergs Xerava C.D. startar i Stochampionatet. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Att vinna Axevallas två största lopp för ston, Guldstoet och Stochampionatet, har bara fyra damer lyckats med i historien. Och det är ingen dålig kvartett! Eller vad sägs om <strong>Ina Scot, Lovely Godiva, Lie Detector</strong> och <strong>Viola Silas</strong>?</p>



<p>I årets finalfält finns fjolårets Guldstovinnare med: Hans R Strömberg-tränade <strong>Xerava C.D. </strong>(e. Uncle Lasse). Men det är mot alla odds som stoet står på startlinjen:<br>– Hon drabbades av kolik den 3 mars. De fick inte igång magen på henne utan veterinären sade att vi var tvungna att bege oss till Veterinärhögskolan i Uppsala. Där fick de göra en buköppning; annars hade hon strukit med, berättar Hans R Strömberg i en intervju med Sulkysport.</p>



<p><a href="https://sulkysport.se/xerava-c-d/" target="_blank" rel="noreferrer noopener">––> Läs hela intervjun med Rättvikstränaren här!</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/08/juristadwm220824adamstromstalltz-617x395.jpg" alt="" class="wp-image-345639"/><figcaption class="wp-element-caption">Jurista blir Daniel Wäjerstens val i Stochampionatet. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap">Daniel Wäjersten har alltså kvalat in två hästar till Stochampionatet och tjejen bakom verket är densamma. Rutinerade Camilla Björk sköter både Jurista och O’Mara Zon. Camilla arbetade i många år hos Svante Båth, men när denne flyttade söderut stannade Camilla kvar i Kovland utanför Sundsvall och började arbeta hos Daniel Wäjersten på samma träningsanläggning.</p>



<p><strong>Här är hästskötarna bakom de tolv finalisterna:</strong></p>



<ol class="wp-block-list">
<li>Joviality – Mikaela Engström</li>



<li>Bold Face – Minna Rosimo</li>



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



<li>Queen Belina – Jenny Martinsson</li>



<li>Aurelia Express – Katariina Murmonen</li>



<li>Miking – Anja Jörgensen</li>



<li>Global Dancer – Tuva Halling</li>



<li>Xerava C.D. – Martina Jonsson</li>



<li>Jennifer Sisu – Rebecca Sjöberg</li>



<li>Jurista – Camilla Björk</li>



<li>O’Mara Zon – Camilla Björk</li>



<li>Mary Ann Lane – Josefin Jenssen</li>
</ol>


<div class="factbox full ">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									Vinnare av Stochampionatet 1969-2024								</h3>
<div class="content">
<p><em>År/vinnare – Far – Mor – Körsven – Tränare – Tid</em></p>
<ul class="wp-block-list">
<li>1969 <strong>Goldhook</strong> – Tampiko – Goldie Fortuna – Gösta Nordin – Gösta Nordin – 1.24,2a</li>
<li>1970 <strong>Famita</strong> – Torg – Ethel Bulwark – Sven Karlsson – Sven Karlsson&nbsp; – 1.22,8a</li>
<li>1971 <strong>Benti Ribb</strong> – Smokey Hanover – Benboe Söndergaard – Olle Elfstrand – Olle Elfstrand – 1.24,1a</li>
<li>1972 <strong>Erva Scout</strong> – Scout Master – Minerva – Olle Lindqvist – Olle Lindqvist – 1.23,4a</li>
<li>1973 <strong>Gaby Bulwark</strong> – Earl Bulwark – Gaby Will – Sören Nordin – Sören Nordin – 1.23,4a</li>
<li>1974 <strong>Therese Bunter</strong> – King Bunter – Duchesse Faune – Göran Kärrstrand – Göran Kärrstrand – 1.23,9a</li>
<li>1975 <strong>Fonians</strong> – Earl Bulwark – Ann Gay – Sören Nordin – Sören Nordin – 1.22,5a</li>
<li>1976 <strong>Sweet Janki</strong>&nbsp; – Nagasaki – Laila Scott – Gunnar Wallberg – Gunnar Wallberg – 1.20,9a</li>
<li>1977 <strong>Holly Rodney</strong>&nbsp; – Captain Rodney – Kickan Fast – Stig H Johansson – Stig H Johansson – 1.22,9a</li>
<li>1978 <strong>Baroness Hill</strong>&nbsp; – Brother Hill – Pasodoble – Thomas Nilsson – Thomas Nilsson – 1.22,8a</li>
<li>1979 <strong>May Björn</strong>&nbsp; – Björn – Harlans Gaily – Olle Goop – Alf Lindholm (a) – 1.19,8a</li>
<li>1980 <strong>Queensway</strong>&nbsp; – The Prophet – Maria Folsted – Göran E Johansson – Bo Eriksson (a) – 1.21,2a</li>
<li>1981 <strong>Varia</strong> – Frosted Yankee – Imperia – Stig H Johansson – Kaj Widell – 1.17,3a</li>
<li>1982 <strong>Brilana</strong> – Net Profit – Bibbi Sweep – Erik Berglöf – Erik Berglöf – 1.19,4a</li>
<li>1983 <strong>Sweet Bear</strong> – Shatter Way – Kicki Bear – Olle Goop – Olle Goop – 1.18,2a</li>
<li>1984 <strong>Pay the Bill</strong> – Quick Pay – Rimmilli Truck – Sven-Gunnar Andersson – S-G Andersson – 1.17,2a</li>
<li>1985 <strong>Kristina Palema</strong> – Quick Pay – Haha Arden – Bo Näslund – Bo Näslund – 1.18,7a</li>
<li>1986 <strong>Intact</strong>&nbsp; – Netted – Misty Sister – Olle Goop – Olle Goop – 1.18,6a</li>
<li>1987 <strong>Emilie Palema</strong> – Pershing – Haha Arden – Bo Näslund – Bo Näslund – 1.17,3a</li>
<li>1988 <strong>Gina Roy</strong>&nbsp; – Speedy Min – Regina Roy – Stig H Johansson – Stig H Johansson – 1.17,3a</li>
<li>1989 <strong>Tamila Gloria</strong> – Glasgow – Lycka Me – Jim Frick – Olle Goop – 1.17,3a</li>
<li>1990 <strong>Queen L.&nbsp;</strong> – Crowntron – Attila L. – Stig H Johansson – Stig H Johansson – 1.16,8a</li>
<li>1991 <strong>Bowls Lady</strong> – Super Bowl – Lady Lexington – Stig H Johansson – Stig H Johansson – 1.16,6a</li>
<li>1992 <strong>Royaling</strong>&nbsp; – Royal Prestige – Precious Glory – Örjan Kihlström – Tommy Hanné – 1.17,4a</li>
<li>1993 <strong>Ina Scot</strong> – Allen Hanover – Lovina Grefgård – Kjell P Dahlström – Kjell P Dahlström – 1.15,2a</li>
<li>1994 <strong>Lovely Godiva</strong> – Ideal du Gazeau – Keystone Gwen – Per-Olof Pettersson – Per-Olof Pettersson – 1.15,1a</li>
<li>1995 <strong>Fiona San</strong> – Tibur – Norleah Hanover – Stig H Johansson – Stig H Johansson – 1.16,1a</li>
<li>1996 <strong>Krossed Out</strong> – Super Arnie – Seven Of Diamonds – Hans-Owe Sundberg – M-Å Törnqvist (a) – 1.16,1a</li>
<li>1997 <strong>Carolinas Mystic</strong> – Karate Chop – Coventry Lobell – Björn Goop – Björn Goop – 1.15,8a</li>
<li>1998 <strong>Simb Capi</strong> – Probe – Cap and Tassel – Lutfi Kolgjini – Lutfi Kolgjini – 1.17,0a</li>
<li>1999 <strong>Princess V.</strong> – Zoot Suit – Can Can Tim – Olle Goop – Olle Goop – 1.16,9a</li>
<li>2000 <strong>Sweet As Candy</strong> – Smasher – Pretty I. – Björn Goop – Lars-Eric Magnusson – 1.17,3a</li>
<li>2001 <strong>Volita du Ling</strong> – Super Arnie – Valinda – Erik Adielsson – Tommy Hanné – 1.15,5a</li>
<li>2002 <strong>Pine Dust</strong> – Pine Chip – Web Chance – Örjan Kihlström – Stefan Hultman – 1.15,7a</li>
<li>2003 <strong>Je t’Aime Dream</strong> – Sugarcane Hanover – Je t´Aime Hornline – Stig H Johansson – Stig H Johansson – 1.14,5a</li>
<li>2004 <strong>Giant Diablo</strong> – Supergill – Giant Rhytm – Örjan Kihlström – Roger Walmann – 1.15,7a</li>
<li>2005 <strong>Fama Currit</strong> – Viking Kronos – Union Madigan – Peter Ingves – Petri Puro – 1.15,5a</li>
<li>2006 <strong>Mad Marke</strong> – Vip Tilly – Madonna Hornline – Stefan Söderkvist&nbsp; – Mikael Selin – 1.15,1a</li>
<li>2007 <strong>Vala Boko</strong> – Alf Palema – Flordalie – Jorma Kontio – Timo Nurmos – 1.14,4a</li>
<li>2008 <strong>Lie Detector</strong> – Varenne – Face Lifted – Örjan Kihlström – Stefan Hultman – 1.14,7a</li>
<li>2009 <strong>Calamara Donna</strong> – Pine Chip – Frosts Octopussy – Örjan Kihlström – Roger Walmann – 1.15,9a</li>
<li>2010 <strong>Viola Silas</strong> – Lindy Lane – Iza Silas – Fredrik Persson – Fredrik Persson – 1.15,9a</li>
<li>2011 <strong>Tamla Celeber</strong> – Cantab Hall – Amanda Celeber – Örjan Kihlström – Roger Walmann – 1.15,2a</li>
<li>2012 <strong>Drillbit Ås</strong> – Chocolatier – Perla d’Hilly – Åke Svanstedt – Svate Båth – 1.15,7a</li>
<li>2013 <strong>Blended Scotch</strong> – Super Photo Kosmos – Hopscotch – Per Linderoth – Per Linderoth – 1.13,2a</li>
<li>2014 <strong>Neona Princess</strong> – Gigant Neo – Dew Princess – Johan Untersteiner – Peter Untersteiner – 1.13,7a</li>
<li>2015 <strong>Some Summit</strong> – Dream Vacation – Graceland Summit – Veijo Heiskanen – Veijo Heiskanen – 1.13,6a</li>
<li>2016 <strong>Galactica</strong> – Super Photo Kosmos – Humla Laday – Lars-Åke Söderholm – Malin Bergström (a) – 1.13,2a</li>
<li>2017 <strong>Ultra Bright</strong> – Zola Boko – Patina – Fredrik Persson – Fredrik Persson – 1.13,0a</li>
<li>2018 <strong>Mellby Free</strong> – Muscle Hill – Mellby Ticket – Björn Goop – Björn Goop – 1.13,5a</li>
<li>2019 <strong>Activated</strong> – Jocose – Marelle – Carl Johan Jepson – Fredrik Wallin – 1.13,2a</li>
<li>2020 <strong>Diana Zet</strong> – Hard Livin – Maria Lb – Örjan Kihlström – Daniel Redén – 1.15,3a</li>
<li>2021 <strong>Honey Mearas</strong> – Readly Express – Khao Manee – Örjan Kihlström – Daniel Redén – 1.12,8a</li>
<li>2022 <strong>Great Skills</strong> – Ready Cash – Prowess Kronos – Daniel Wäjersten – Daniel Wäjersten – 1.12,5a</li>
<li>2023 <strong>Joy Sisu</strong> –&nbsp;Brillantissime – Southwind Eliza – Mika Forss – Petri Salmela – 1.12,3a</li>
<li>2024 Kinglet Bird – Nuncio – Vladzia Mauzun –&nbsp;Örjan Kihlström – Daniel Redén –&nbsp;1.13,4a</li>
</ul></div>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
