
<p class="has-drop-cap">Av tränarna bakom årets finalister har fyra redan fått uppleva känslan att vinna Stochampionatet som tränare en eller flera gånger. Daniel Redén och Roger Walmann har dessutom gjort det tre gånger, medan Daniel Wäjersten (<strong>Great Skills</strong>) och Björn Goop (<strong>Mellby Free</strong>) har en vinst vardera.<br>Dessa fyra står också bakom fyra av sex försöksvinnare – <strong>Screen Time Limit, S.G.Empress, Great Knowledge</strong> och <strong>La Yuca</strong> – och finns uppradade från spår två till fem bakom startbilen i eftermiddag.</p>



<p>Daniel Redén är ensam om att ha två chanser i loppet, då La Yuca får sällskap av <strong>Mellby Maleficent</strong> (e. Propulsion), som tog finalplats som tvåa i försöket.<br>– La Yuca gick bra i försöket. Som väntat taktade hon lite, vilket hon brukar göra när hon inte har startat på ett tag, vilket var tanken. Med det loppet i kroppen så kommer hon förhoppningsvis vara i ännu bättre form nu och varmare i kroppen. Det blir ett spännande lopp, hoppas vi har lite tur på vägen och att hon får spela ut sin speed, säger Daniel Redén på Stall Zets hemsida.</p>



<p>Två trä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>Daniel Redén – 3 – Diana Zet 2020, Honey Mearas 2021, Kinglet Bird 2024</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>
</ul>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/10/14layuca-617x333.jpg" alt="" class="wp-image-645636"/><figcaption class="wp-element-caption">La Yuca. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



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



<p>2.640 meter autostart, förstapris 2.400.000 kronor<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li><strong>Elegance Silvio</strong> (e. Maharajah) – Johan Untersteiner</li>



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



<li><strong>S.G.Empress</strong> (e. Readly Express) – Rikard N Skoglund (Roger Walmann)</li>



<li><strong>Great Knowledge</strong> (e. Fourth Dimension) – Björn Goop</li>



<li><strong>La Yuca</strong> (e. Face Time Bourbon) – Örjan Kihlström (Daniel Redén)</li>



<li><strong>One Lady Boko</strong> (e. Tactical Landing) – Mats E Djuse (André Eklundh)</li>



<li><strong>Tangerina</strong> (e. Perfect Spirit) – Carl Johan Jepson (Ulf Stenströmer</li>



<li><strong>Tintarella</strong> (e. Fabulous Wood) – Thomas Dalborg</li>



<li><strong>Panthere d’Inverne</strong> (e. Brillantissime) – André Eklundh</li>



<li><strong>Ebba Kuce</strong> (e. Who’s Who) – Stefan Persson (Thomas Madsen)</li>



<li><strong>Mellby Maleficent</strong> (e. Propulsion) – Per Linderoth (Daniel Redén)</li>



<li><strong>Billie Parker</strong> (e. Bird Parker) – Gustav Johansson (Jerry Riordan)</li>
</ol>



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



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



<p>Samtliga tolv finalister är med i premiechansen och tävlar om dubbla prispengarna. Prisskalan i Stochampionatet blir därmed:<br>2.400.000-1.200.000-600.000-288.000-192.000-120.000 kr.</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/06/s.g.empressok-617x333.jpg" alt="" class="wp-image-597462"/><figcaption class="wp-element-caption">S.G.Express. Foto Adam Ström/Stalltz.se</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 Ina Scot, Lovely Godiva, Lie Detector och Viola Silas?</p>



<p>I årets finalfält finns fjolårets Guldstovinnare <strong>S.G.Empress</strong> (e. Readly Express) i startfältet och Roger Walmanns hopp har sprungit in mest av årets finalister. 3.822.500 kronor har det blivit hittills för dottern till Tom Horpestads toppsto <strong>Riva del Sole</strong> (e. Gentle Star), 1.11,5ak/3.716.024 kr.<br>Riva del Sole tog en av sina 22 segrar under Stochampionatshelgen som fyraåring, men inte i det stora loppet. Hon var nämligen inte anmäld och segrade istället i ett vanligt stolopp.</p>



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



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



<p class="has-drop-cap">För tre år sedan spurtade Daniel Wäjersten hem sin dittills största seger som tränare och kusk när <strong>Great Skills</strong> (e. Ready Cash) vann Stochampionatet på 1.12,5a. </p>



<p>I eftermiddag är hans hopp finskägda <strong>Screen Time Limit</strong> (e. Face Time Bourbon), som efter att ha vunnit långa E3 i Reijo Liljendahls regi anslöt till Wäjerstens stall förra sommaren. Där kvalade hon in till Oaks efter försöksvinst (galopp i finalen) och avslutade året med andraplatsen i Breeders Crown-finalen.</p>



<p>I år har siktet varit inställt på Axevalla och i försöket kom första årssegern.<br>– Hon var lite sisådär i början av säsongen, men visade sitt gamla goda jag på Dannero. Nu känns det som att hon är i ordning igen, sade Daniel Wäjersten efter försöket.</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>Kinglet Bird</strong> (e. Nuncio) förra året var det hans nionde seger i Axevallas storlopp. Fler än någon annan. </p>



<p><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, Diana Zet (e. Hard Livin) 2020, Honey Mearas (e. Readly Express) 2021 och Kinglet Bird (e. Nuncio) 2024.</p>



<p>Med nio kusksegrar i Stochampionatshistorien har han två fler än 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>Örjan vann ett av uttagningsloppen och kör försöksvinnaren <strong>La Yuca</strong> (e. Face Time Bourbon) i finalen.</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 tog sin första storseger som kusk när han 1997 vann med den av pappa Olle tränade <strong>Carolinas Mystic</strong> (e. Karate Chop) som 46-oddsare. Sedan dess har det blivit ytterligare en vinst, med egentränade <strong>Mellby Free</strong> (e. Muscle Hill).</p>



<p>I år har han åter ett egentränat sto i loppet i Stall Segerhuvas <strong>Great Knowledge</strong> (e. Fourth Dimension). Stall Segerhuva har många storloppsvinster genom åren, men saknar vinst i stonas största lopp.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/05/pantheredinverneaem250503adamstromstalltz-617x368.jpg" alt="" class="wp-image-714729"/><figcaption class="wp-element-caption">Panthere d&#8217;Inverne och André Eklundh vid segern i Drottning Silvias Pokal i våras. Foto: Adam Ström/stalltz.se
</figcaption></figure>



<p class="has-drop-cap">Under drygt 40 år har samma sto vunnit både Drottning Silvias Pokal och Stochampionatet 14 gånger. Och det är ingen dålig samling blågula ston som tar plats på listan över dubbelvinnare.</p>



<p>I år kan André Eklundh-tränade <strong>Panthere d’Inverne</strong> (e. Brilliantissime) göra dem sällskap. Stoet imponerade i uttagningsloppet tillsammans med André och skar mållinjen som vinnare med gott om krafter i behöll efter kortare uppehåll.<br>– Man hade dröm om det här scenariot att hon skulle få glida till ledning och gå den lätta vägen. Allt blev som jag önskade och var så fin som jag hoppades. Första 200 handlar om att få iväg henne felfritt, för hon är inte helt stabil. Hon har lärt sig det nu, men det går inte att köra för någon position. Det går inte bråka för mycket för henne och det var lagom tempo. Hon gick i mål med gott om krafter kvar. Det var ett väldigt skönt besked att hon var där hon ska, sade André Eklundh efter försökssegern.</p>



<p>André Eklundh kvalade även in <strong>One Lady Boko</strong> (e. Tactical Landing) till final.</p>



<p><strong>Hästarna som vunnit Drottningpokalen och Stochampionatet:</strong></p>



<p><em>År, häst (far) – Tränare)</em></p>



<ul class="wp-block-list">
<li>1985 Kristina Palema (e. Quick Pay) – Bo Näslund</li>



<li>1986 Intact (e. Netted) – Olle Goop</li>



<li>1988 Gina Roy (e. Speedy Min) – Stig H Johansson</li>



<li>1991. Bowls Lady (e. Super Bowl) – Stig H Johansson</li>



<li>1993 Ina Scot (e. Allen Hanover) – Kjell P Dahlström</li>



<li>1998 Simb Capi (e. Probe) – Lennart Wikström/Lutfi Kolgjini</li>



<li>2000 Sweet As Candy (e. Smasher) – Lars-Eric Magnusson</li>



<li>2004 Giant Diablo (e. Supergill) – Roger Walmann</li>



<li>2005 Fama Currit (e. Viking Kronos) – Petri Puro</li>



<li>2008 Lie Detector (e. Varenne) – Stefan Hultman</li>



<li>2010 Viola Silas (e. Lindy Lane) – Fredrik Persson</li>



<li>2011 Tamla Celeber (e. Cantab Hall) – Roger Walmann</li>



<li>2019 Activated (e. Jocose) – Fredrik Wallin</li>



<li>2020 Diana Zet (e. Hard Livin) – Daniel Redén</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/2025/06/johanuntersteiner-617x333.jpg" alt="" class="wp-image-732826"/><figcaption class="wp-element-caption">Johan Untersteiner. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Som kusk vann Johan Untersteiner Stochampionatet med den av pappa Peter tränade <strong>Neona Princess</strong> (e. Gigant Neo) 2014. Johan har själv gått segerlös från fem finaler med egentränade ston och tog ifjol främsta placeringen när <strong>Farina</strong> (e. Readly Express) slutade tvåa. </p>



<p>Nu har Johan laddat om och tuffa <strong>Elegance Silvio</strong> (e. Maharajah) är hans bidrag. Stoet har matchats tufft under våren och sommaren och kan ståta med tredjeplatsen i Drottning Silvias Pokal och silverpengen i Stosprintern som uppladdning inför detta.<br>– Min häst har haft täta starter så det var skönt att hon inte behövde gå i botten. Det blev ökning 700 kvar och hon är så kvick i benen, så det kändes väldigt enkelt. Det är tufft med final snart efter Stosprintern, men vi gjorde resan med Neonas Princess och det gick vägen, sade Johan Untersteiner efter försöket.</p>



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



<p class="has-drop-cap"><strong>Drillbit Ås</strong> (e. Chocolatier), 1.10,1ak/2.521.000 kr, vann Stochampionatet och slutade tvåa i Derbystoet i regi Svante Båth. Vid storloppssegern på Axevalla satt Åke Svanstedt i vagnen och inkasserade karriärens seger 6.000!</p>



<p>I Thomas Madsen-tränade <strong>Ebba Kuce</strong> (e. Who’s Who) har Drillbit Ås sin främsta avkomma – och en Stochampionatsfinalist.</p>



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



<p><strong>Inte sedan Bo Näslund triumferade med Emilie Palema (e. Pershing) har det blivit hemmaseger i Axevallas största lopp. I år finns dubbla hemmahästar på startlinjen.</strong></p>



<p><a href="https://sulkysport.se/hennes-hjarta-ar-stort/" target="_blank" rel="noreferrer noopener">Läs mer om Ulf Stenströmers Tangerina (e. Perfect Spirit) här!</a></p>



<p><a href="https://sulkysport.se/tintarella-ar-speedig/" target="_blank" rel="noreferrer noopener">Läs mer om Thomas Dalborgs Tintarella (e. Fabulous Wood) här!</a></p>



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



<p class="has-drop-cap">Det är stor spridning på hingstsidan i årets Stochampionat. Hela elva avelshingstar står bakom de tolv finalisterna och fem hingstar har sin första startande avkomma i loppet.</p>



<p>Av fäderna är det en som vet hur det känns att vinna sedan tidigare. Readly Express slog till med en Stochampionatsvinnare redan i första kullen född 2017 när Daniel Redén-tränade <strong>Honey Mearas</strong> vann 2021 års upplaga.<br>Sveriges hingchampion Maharjah har haft tio finalister tidigare, men saknar fortfarande en seger. Bästa placeringen är Schatzi Faylines tredjeplats för åtta år sedan.</p>



<p><strong>Avelshingstarnas resultat:</strong><br><em>Hingst (finalister 2025) – Tidigare startande – Resultat</em></p>



<ul class="wp-block-list">
<li>Bird Parker (1) – 1 – Graces Bird (0) 2024</li>



<li>Brillantissime (1) – 2 – Global Collection (5) 2022, Joy Sisu (1) 2023</li>



<li>Face Time Bourbon (2) – 1 – Naomi Bros (0) 2024</li>



<li>Maharajah (1) – 10 – Schatzi Fayline (3) 2017, Mulligan (4) 2017, Vero Spiro (6) 2019, Mahma Lane (0) 2020, Deborah S.H. (6) 2022, O’Mara Zon (6) 2023, Miking (0) 2023, Carmita Silvio (4) 2024, Famous Scotch (0) 2024, Nouchka di Quattro (0) 2024</li>



<li>Propulsion (1) – 1 – Jennifer Sisu (2) 2023</li>



<li>Readly Express (1)  7 – <strong>Honey Mearas</strong> (1) 2021, Helluva Am (0) 2021, Tilda Express (0) 2021, Aurelia Express (5) 2023, Farina (2) 2024, Daim Brodda (3) 2024, Queen of Power (0) 2024</li>
</ul>



<p><em>Fabulous Wood (1), Fourth Dimension (1), Perfect Spirit (1),  Tactical Landing (1) och Who’s Who* (1) har inte haft några tidigare startande avkommor i Stochampionatet.</em><br>* första kullen.</p>



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



<p class="has-drop-cap">Blott två av Stochampionatshästarna såldes på auktion som ettåringar, två andra har bytt ägare som äldre. För <strong>One Lady Boko</strong> (e. Tactical Landing) betalade finska ägarna Oraviston Talli Oy en kvarts miljon kronor på Elitauktionen 2022. <br>Stoet tävlade till och med treåringssäsongen i Jonna Irris regi, innan hon i slutet av förra året både bytte ägare och tränare. Hannu Korpi – mannen bakom bland andra 1.08,3-travaren <strong>Hierro Boko</strong> (e. From Above) – tog över innan han i början av kommaren satte stoet i träning hos André Eklundh.</p>



<p>100.000 kronor var priset när <strong>Panthere d’Inverne</strong> (e. Brillantissime) ropades in på Kriterieauktionen som ettåring.</p>



<p><strong>Här är auktionspriserna:</strong><br><em>Namn – Auktion – Pris</em></p>



<ul class="wp-block-list">
<li>One Lady Boko – Elitauktionen – 250.000 kr</li>



<li>Tangerina* – Travera – 110.000 kr</li>



<li>Panthere d’Inverne – Kriterieauktionen – 100.000 kr</li>
</ul>



<p><strong>Fotnot: </strong>Great Knowledge ropades tillbaka på Menhammar Online för 250.000 kr. Tintarella var ett återrop såväl på Åby Yearling Sale som på Travera i år för 80.000 respektive 940.000 kronor, men bytte ägare efter senaste auktionen.</p>



<p><em>* Tangerina ropades åter på tyska Derbyauktionen som ettåring för 14.000 euro och såldes som treåring. </em></p>



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



<p class="has-drop-cap">Att så få hästar sålts på auktion har sin tydliga förklaring i startlistan. Hela åtta av tolv finalister ägs nämligen fortsatt av sin uppfödare!</p>



<p>Flera av uppfödarna har också firat framgångar i loppet tidigare. Menhammar Stuteri är bäst i klassen med tre uppfödda vinnare i <strong>Lie Detector</strong> (e. Varenne), <strong>Ultra Bright</strong> (e. Zola Boko) och <strong>Activated</strong> (e. Jocose).<br>Mellby Gård både födde upp och ägde 2018 års vinnare <strong>Mellby Free</strong> (e. Muscle Hill) och Boko Stables tog sin uppfödarvinst genom <strong>Vala Boko</strong> (e. Alf Palema) 2007.</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>Kristina Palema</strong> (e. Quick Pay) och två år senare <strong>Emelie Palema</strong> (e. Pershing).<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><strong>Här är ägare och uppfödare bakom Stochampionatshästarna:</strong><br><em>Häst – Ägare – Uppfödare</em></p>



<ol class="wp-block-list">
<li>Elegance Silvio – Stall Silvio AB, Åstorp – Stall Silvio AB, Åstorp</li>



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



<li>S.G.Empress – Skärgården Stuteri AB, Väddö – Skärgården Stuteri AB, Väddö</li>



<li>Great Knowledge – Stall Segerhuva – Menhammar Stuteri AB, Ekerö</li>



<li>La Yuca – Eagles Rising AB, Bjärred – Eagles Rising AB, Bjärred</li>



<li>One Lady Boko – Hannu Korpi, Finland – Boko Stables Holland BV, Nederländerna</li>



<li>Tangerina – Lars Lindberg Försäljning KB, Mariestad – Lina Alm, Klågerup</li>



<li>Tintarella – Kikati Stable – Bord 18 HB, Gunnilse</li>



<li>Panthere d’Inverne – Couisine RPG &#038; development HB, Vrigstad – Invernum Stuteri AB, Stockholm</li>



<li>Ebba Kuce – Curt-Olof Dahl, Kalmar – Cecilia &#038; Curt-Olof Dahl</li>



<li>Mellby Maleficent – Mellby Gård AB, Malmö – Mellby Gård AB, Malmö</li>



<li>Billie Parker – Riordan Racing AB, Halmstad – Riordan Stables AB, Halmstad</li>
</ol>



<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. Fem hingstar ståtar med två vinnare vardera och kvintetten kan alltså få sällskap av <strong>Readly Express</strong> (S.G.Empress) eller <strong>Brillantissime</strong> (Panthere d’Inverne) efter dagens final.</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>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/01/readycashprisflores-617x333.jpg" alt="" class="wp-image-678483"/><figcaption class="wp-element-caption">Constanza Flores när det begav sig som skötare till självaste Ready Cash hos Philippe Allaire. 
Foto Gerard Forni</figcaption></figure>



<p class="has-drop-cap">Hon skötte självaste Ready Cash de första åren av hästens karriär hos Philippe Allaire och har själv i vinter tagit en tränarseger på Vincennes med <strong>Jolicoeur</strong> (e. Atlas de Joudes).<br>Idag är Constanza Flores skötaren bakom två Stochampionashästar, nämligen André Eklundhs duo <strong>Panthere d’Inverne</strong> och <strong>One Lady Boko</strong>.</p>



<p><strong>Här är hästskötarna bakom Stochampionatsfinalisterna.</strong><br><em>Hästskötare – häst</em></p>



<ul class="wp-block-list">
<li>Jeanette Karlsson – Elegance Silvio</li>



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



<li>Malin Boman Friberg – S.G.Empress</li>



<li>Ayse Könec – Great Knowledge</li>



<li>Lina Pergenius – La Yuca</li>



<li>Constanza Flores – One Lady Boko</li>



<li>Maria Wedell – Tangerina</li>



<li>Hannah Matikainen – Tintarella</li>



<li>Constanza Flores – Panthere d’Inverne</li>



<li>Wilma Sörmlind – Ebba Kuce</li>



<li>Cecilia Lindén – Mellby Maleficent</li>



<li>Matilda Nilsson – Billie Parker</li>
</ul>


<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>
