
<p class="has-drop-cap wp-block-paragraph">1Den 20 april 2022 gick en av svensk travsports allra största ur tiden. Olle Goop blev 78 år. I eftermiddag hedras han på sin mångåriga hemmabana Åby med att namnge Svenskt Mästerskap – Olle Goops Pokal – för tredje året. Premiären slutade med en känslosam seger för sonen Björn bakom <strong>Brother Bill</strong> (e. From Above) och ifjol segrade Robert Bergh med Power (e. Googoo Gaagaa).</p>



<p class="wp-block-paragraph">Lördagens stora namn är förstås <strong>San Moteur</strong> (e. Panne de Moteur). Björn Goop har inte vunnit loppet som tränare. Däremot ståtar han med dubbla kusksegrar med <strong>Readly Express</strong> (e. Ready Cash) och <strong>Brother Bill</strong> (e. From Above).</p>



<p class="wp-block-paragraph">Håkan Arvidsson lämnade formrapport kring San Moteur i V65 Direkt:<br>– Jag tyckte att vi hade formen på topp på Åby, men det blev fel barfota. Vi gjorde en tabbe och får ta på oss det. I Halmstad var han så fin han kan vara. Björn sade redan i Eskilstuna (18 juli, reds. anm.) att vi kan köra från slut varje gång med honom, han kan ju springa oerhört snabbt en bit. Jag lämnar över taktiken till Björn och hästen har många bra egenskaper. Klaffar det 100 procent är han väldigt svårslagen.</p>



<p class="wp-block-paragraph">Som tränare räknade Olle Goop in 7.696 segrar och hade bara Stig H Johansson som sin överman, medan han bokförde sig för 6.745 vinster i sulkyn. Hela 66 banchampionat blev det också under den långa och framgångsrika karriären. Dessutom tiofaldig allsvensk kuskchampion och det kan också nämnas att Olle var champion på Åby 26 år i följd, åren 1973-1998.<br>Listan över storloppssegrar är lång och när det gäller Svenskt Mästerskap som Olle nu namnger, så har han fem triumfer som kusk. Tre tränades av Olle själv, medan han anlitades som gästkusk av Stig H Johansson bakom dubble mästaren <strong>Utah Bulwark</strong>:</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/10/knabegoopollesm74scaled-617x347.jpeg" alt="" class="wp-image-364688"/><figcaption class="wp-element-caption">Knabe och Olle Goop efter SM-segern 1974. Nu har Olle Goop fått namnge loppet: Svenskt Mästerskap – Olle Goops Pokal. Foto stalltz.se</figcaption></figure>



<ul class="wp-block-list">
<li>1974 <strong>Knabe</strong> (e. Freund Werner) – 1.18,8a</li>



<li>1983 <strong>Speedy Magnus</strong> (e. Speedy Spin) – 1.17,0a</li>



<li>1985 <strong>Utah Bulwark</strong> (e. Utah IX) – 1.15,8a</li>



<li>1986 <strong>Utah Bulwark</strong> (e. Utah IX) – 1.14,8a</li>



<li>1990 <strong>Bland And White</strong> (e. Zoot Suit) – 1.15,7a</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/2021/10/francesbulwarknordin-617x347.jpg" alt="" class="wp-image-222053"/><figcaption class="wp-element-caption">Frances Bulwark vann Svenskt Mästerskap sex gånger tillsammans med Sören Nordin. Foto Stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2Svenskt Mästerskap föddes på Jägersro 1939 då Sören Nordin vann med <strong>Quart</strong> Axworthy (e. Fels) och precis som många andra stora löpningar i Sverige så alternerade värdskapet för loppet mellan de tre storstadsbanorna Jägersro, Solvalla och Åby under många år. Sedan 1966 är SM bofast på Åby.</p>



<p class="wp-block-paragraph">SM-kungen i Sverige då? Tolv segrar i Svenskt Mästerskap räknade just Sören Nordin in under sin fantastiska tränarkarriär i Sverige och hälften av vinsterna kom med travdrottningen <strong>Frances Bulwark</strong> (e. Bulwark). </p>



<p class="wp-block-paragraph">Stig H Johansson skuggar en seger bakom Sören med sina elva triumfer. Dessa togs med sju olika hästar, där en annan travdrottning <strong>Queen L. </strong>(e. Crowntron) var främst i klassen med tre triumfer. Ytterligare en travare vann SM tre gånger: Sixten Lundgrens <strong>Balett</strong> (e. Bulwark).</p>



<p class="wp-block-paragraph"><strong>Flest tränarsegrar i SM:</strong></p>



<ul class="wp-block-list">
<li>Sören Nordin – 12</li>



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



<li>Gösta Nordin – 5</li>



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



<li>Olle Goop – 3</li>



<li>Stefan Hultman – 3</li>



<li>Sixten Lundgren – 3</li>



<li>Gunnar Nordin – 3</li>



<li>Åke Svanstedt – 3</li>
</ul>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/09/28v75.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till lördagens SM-tävlingar på Åby.</a></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/2023/08/greatskillsdwm230816adamstromstalltz-617x393.jpg" alt="" class="wp-image-484399"/><figcaption class="wp-element-caption">Great Skills och Daniel Wäjersten. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3Sju SM-guld ska delas ut på Åby (första start 14.45) i eftermiddag och en som kan försvara sitt SM-guld är Daniel Wäjerstens toppsto <strong>Great Skills</strong> (e. Ready Cash), som kommer från femteplatsen i getingboet i Sundsvall Open Trot, där <strong>Francesco Zet</strong> (e. Father Patrick) vann på världsrekord 1.09,4a/2.140 meter.</p>



<p class="wp-block-paragraph">Great Skills är ett av två singelstreck signerat Sulkysports expert Magnus Blom och <a href="https://sulkysport.se/spelstugan/v75-tips-tva-ston-spikas-under-sm-dagen/" target="_blank" rel="noreferrer noopener">hela tipsgenomgången till V75 finns här!</a></p>



<p class="wp-block-paragraph"><strong>Här är fjolårets svenska mästare på varmblodssidan.</strong></p>



<ul class="wp-block-list">
<li>Öppna: <strong>Power</strong> (e. Googoo Gaagaa) – Robert Bergh</li>



<li>Ston: <strong>Great Skills</strong> (e. Ready Cash) – Daniel Wäjersten</li>



<li>Monté: <strong>L.L.Royal</strong> (e. Revenue) – Christina A Hande (Robert Bergh)</li>



<li>Amatörer: <strong>Jolicoeur</strong> (e. Atlas de Joudes) – Jonathan Carre (Constanza Flores)</li>



<li>Ungdomar: <strong>Putte</strong> (e. S.J.’s Caviar) – Tom Johansson (Anders Svanstedt)</li>



<li>Lärlingar: <strong>Kingslayer Pellini</strong> (e. Up And Quick) – Oskar Florhed (Daniel Wäjersten)</li>



<li>Montéryttare: <strong>Country Sound</strong> (e. Quarcio du Chene) – Anna Erixon (Anders Hultgren)</li>
</ul>



<p class="wp-block-paragraph">I år har fyra guld delats ut. Dam-SM avgjordes på Bergsåker för en dryg månad sedan med Anders Eriksson-tränade <strong>Sparky’s Dream</strong> (e. Maharajah) och Agnes Larsson som vinnare.<br>Kallblodens tre SM-guldmedaljer har också delats ut. Öppna SM vann Gunnar Melanders <strong>Månlykke A.M.</strong> (e. Månprinsen A.M.), Jan-Olov Persson-tränade <strong>Stjärnblomster</strong> (e. B.W.Modde) vann sto-SM och i torsdags plockade <strong>Guli Fantom</strong> (e. Bork Odin), tränad av Jörgen Westholm, hem SM-guldet i monté.</p>



<p class="wp-block-paragraph">Vid sidan om guldjakten på Åby ligger platser i finalen av Grand Prix de l’U.E.T. (€400.000) på Vincennes om två veckor i potten när det körs två uttagningslopp till Grand Prix de l’U.E.T. mned svenske Derbyvinnaren <strong>Fame And Glory</strong> (e. Tactical Landing) som det största namnet. De två första försöken kördes på Vincennes igår kväll.</p>



<p class="wp-block-paragraph">På svensk mark avslutas lördagen ned breddlopp på Romme (start 18.30).</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/09/240928.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till lördagens tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4Både Timo Nurmos (tre gånger) och Kari Lähdekorpi (en gång) har vunnit Finskt Travkriterium som tränare med basen på svensk mark. I eftermiddagens storlopp för treåringarna i Tammerfors saknas i stort sett helt svensk anknytning. Solvallalicensierade Mika Forss kör <strong>Callela Estelle</strong> (e. Fabulous Wood), som han även lotsade till andraplatsen i kvalet.</p>



<p class="wp-block-paragraph">Kungen av försöken var Pekka Korpi. Nestorn vann dubbla uttagningslopp – <strong>Ginza </strong>(e. Fabulous Wood och <strong>Arctic Emerald</strong> (e. Express Duo) – och hans vinnare var dessutom de två snabbaste i försöken.<br>Pekka Korpi har åtta tränarsegrar i finska Kriteriet. Den senaste kom för två år sedan genom <strong>Corazon Combo</strong> (e. Express Duo).</p>



<p class="wp-block-paragraph"><strong>Startlista Finskt Travkriterium, Tammerfors</strong><br><em>2.600 meter autostart, förstapris: 90.000 euro.</em></p>



<ul class="wp-block-list">
<li><strong>Lil Runner</strong> (e. So Perfect) – Antti Teivanen</li>



<li><strong>Neymar Web</strong> (e. Like A Prayer) – Santtu Raitala (Anne Kangas)</li>



<li><strong>One Of</strong> (e. Maharajah) – Hannu Torvinen (Hannu-Pekka Korpi)</li>



<li><strong>Ginza</strong> (e. Fabulous Wood) – Ilkka Korpi (Pekka Korpi)</li>



<li><strong>Arctic Emerald</strong> (e. Express Duo) – Pekka Korpi</li>



<li><strong>Callela Estelle</strong> (e. Fabulous Wood) – Mika Forss (Markku Nieminen)</li>



<li><strong>Stonecapes Xantee</strong> (e. Brillantissime) – Ari Moilanen (Antti Veteläinen)</li>



<li><strong>Playmaker Sala</strong> (e. Maharajah) – Olli Koivunen (Harri Koivunen)</li>



<li><strong>Goodbrother</strong> (e. Knows Nothing) – Tuomas Pakkanen (Martti Pellikka)</li>



<li><strong>Shackhills Viking</strong> (e. Maharajah) – Jari Kinnunen</li>



<li><strong>Dollar Hanven</strong> (e. Andover Hall) – Tommi Kylliäinen (Jarno Kauhanen)</li>



<li><strong>Harley</strong> (e. Mythical Lindy) – Jyrki Tammimentsä</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/2024/08/6majblomster3-617x333.jpg" alt="" class="wp-image-618978"/><figcaption class="wp-element-caption">Majblomster vid segern i Derbystoet i Östersund i augusti före Voje Lotta. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">5Idel kallblodslopp blir det på den norska V75-omgången på Biri ikväll, där höjdpunkten är treåringsloppet Biris Uppfödningslopp med 300.000 kronor till vinnaren. Jan-Olov Persson har loppets två svenska hopp i <strong>Skånepågen</strong> (e. Smedheim Solan), som körs av Ole Johan Östre, och <strong>Mitt Hjärtas Hero</strong> (e. Tekno Odin) med Dag-Sveinung Dalen i vagnen.<br>Den sistnämnde kvalade in till svenska Kriteriet, medan Skånepågen inte var med i något av kullens två största lopp.</p>



<p class="wp-block-paragraph">Det stora nam,net i årets upplaga av Biris Uppfödningslopp är förstås obesegrade <strong>Gigant Tider</strong> (e. Norheim Svenn), som varit fläckfri för sin tränare Kjetil Djöseland. Främste utmanre är Öystein Tjomslands <strong>Tangen Martin</strong> (e. Bork Odin), som varit trea och två i årets två Kriteriefinaler.</p>



<p class="wp-block-paragraph">Godbitarna är fler på Biri, där gamla fina kallblodsmärken som Vintilla och Atom Vinter hedras med varsitt lopp. Dessutom blir det dubbla finaler i Veikle Balders stoserie med 175.000 kronor till vinnaren i varje. I fyraåringsklassen dyker norska Stoderbyvinnaren <strong>Voje Lotta</strong> (e. Ängsborken) upp och möter <strong>Prinsesse Ness Tjo</strong> (e. Moe Odin), som galopperade bort andraplatsen i Stoderbyt kort före mål.</p>



<p class="wp-block-paragraph">Det saknas svenskt deltagande i det loppet, men i finalen för de femåriga stona plockar Magnus Jakobsson ut <strong>Maj Mollyn</strong> (e. Dotterud Teddy). Loppets stora favorit är årets norska mästarinna <strong>Christina K. </strong>(e. Odd Herakles) och Vidar Hop.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/09/28biri.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Biris stora kallblodsdag.</a></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/2022/07/wb070922r9rattlemycage-617x346.jpg" alt="" class="wp-image-325545"/><figcaption class="wp-element-caption">Åke Svanstedt-tränade Rattle My Cage och Yannick Gingras. Foto Lisa Photo</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">6Perry Söderbergs <strong>Rattle My Cage</strong> (e. Love You-Caress the Senses), 1.08,6*/$625.256, stallas upp som avelshingst på Peninsula Farm i Kentucky nästa säsong. Avkommorna som tävlar i Kentucky Sire Stakes erhåller en bonus på 50 procent på vinstsumman och Rattle My Cage kommer att kosta 4.000 dollar.<br>Karriären innehåller 42 starter (8-6-7). Största segern togs i Graduate Series ($250.000) som fyraåring och samma år var han finaltvåa i Dayton Trotting Derby ($250.000). Ifjol slutade han trea i finalen i Breeders Crown för äldre travare. </p>



<p class="wp-block-paragraph">Perry Söderberg betalade 40.000 dollar för Love You-sonen som ettåring på Lexington Selected Yearling Sale. Modern <strong>Caress the Senses</strong> (e. Andover Hall), 1.10,6*/$124.515, har också lämnat <strong>Muscles On Fire</strong> (e. Muscle Hill), 1.10,9*/$226.301, och Grandeur (e. Love You), 1.10,6*/$82.270.</p>



<p class="wp-block-paragraph">Modern är halvsyster med <strong>McCarron</strong> (e. Angus Hall), 1.11,6/$269.000. Mormor <strong>Fiery Chip</strong> (e. Pine Chip), 1.10,7*/$223.212 – utsedd till Elitsto i Norge – har lämnat <strong>Hillary B.R.</strong> (e. Muscle Hill), 1.09,9ak*/3.887.236 nok, <strong>Ghazi B.R.</strong> (e. Cantab Hall), 1.10,4ak/2.508.201 nok, norske Derbyvinnaren <strong>El Diablo B.R.</strong> (e. Muscle Hill), 1.11,1ak/2.008.743 nok, och <strong>Angelina B.R.</strong> (e. Angus Hall), 1.12,0ak/1.351.362 nok.</p>



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



<p class="has-drop-cap wp-block-paragraph">7Det fanns förhoppningar om en återkomst till tävlingsbanan, men när åttaårige <strong>Guzz Mearas</strong> (e. Muscle Mass-Intensity Kronos e. Viking Kronos), 1.09,6ak/4.444.720 kr, närmade sig comeback drog han på sig en ny gaffelbandsskada i andra bakbenet. Ikväll säljs andelshästen som avelshingst på Traveras interauktion.</p>



<p class="wp-block-paragraph">Guzz Mearas har hela karriären tränats av Johan Untersteiner och gjort 46 starter (9-13-7) och på meritlistan finns andraplatsen i Sprintermästaren och tredjeplatser i dubbla Breeders Crown-finaler och Europaderbyt. Guzz Mearas avelsvärderades 2021 och gavs betyget ”högt skattat avelsvärde”.</p>



<p class="wp-block-paragraph">Totalt består katalogen av 46 hästar, där merparten – 25 – är starthästar och 13 fölston. På unghästsidan säljs fyra ettåringar och tre tvååringar, däribland en med Elitloppsvinnaren Hohneck som far.</p>



<p class="wp-block-paragraph"><a href="https://www.travera.nu/kopa-hast/" target="_blank" rel="noreferrer noopener">Här går det att se hästarna som bjuds ut och följa budgivningen under kvällen.</a></p>

Fokustema
Sju nyheter vid sju
Läs senare
Får jubla i pappas lopp?
Björns andra chans i Olles lopp. Sören och Stig H i en klass för sig. Är Great Skills nutidens Frances Bulwark? Korpi i segersits inför finska Kriteriet. Enbart kallblodslopp på V75. Sprintermästartvåa säljs – som avelshingst.
Detta och mer i lördagens ”Sju nyheter vid sju”.
Detta och mer i lördagens ”Sju nyheter vid sju”.
