
<p class="has-drop-cap">1 När Moe Odin-sonen Odd Herakles tackade för sig på tävlingsbanan nyligen är kungakronan bland kallbloden vakant. Två hingstar som i högsta grad slåss om tronen är svenskägde <strong>Grisle Odin G.L.</strong> (e. Moe Odin) och Tangen Bork (e. Bork Odin). I Moe Odins Äreslopp på Klosterskogen i eftermiddag möts Öystein Tjomslands stjärntravare.</p>



<p>De har mötts en tidigare. För ett år sedan vann ett år äldre Grisle Odin G.L. ”Meyern” på Bjerke, där Tangen Bork slutade femma. Grisle Odin G.L. ståtar med 27 segrar på 48 starter i karriären, medan Tangen Bork vunnit 18 av 23 starter.</p>



<p>Jan-Olov Persson sänder två hästar till storloppet: <strong>B.W.Sture</strong> (e. Moe Odin) och <strong>Järvsöodin</strong> (e. Järvsöfaks).</p>



<p>Den fantastiske norske kallblodige avelshingsten <strong>Moe Odin</strong> (e. Elding-Moe Vilja), 1.19,3ak/11.320.700 kr, 92 segrar på 160 starter (!), fick lämna jordelivet för ett år sedan hemma hos sin uppfödare Tor-Martin Moe. Moe Odin blev 25 år gammal.</p>



<p>Hans avelsframgångar är enorma och Moe Odin är pappa till 14 vinnare av Kriteriet och Derbyt i Sverige och Norge.</p>



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



<p class="has-drop-cap">2 2018 delade <strong>Belker</strong> (e. Scarlet Knight), 1.11,3am/3.644.795 kr, segern med Bythebook (e. Googoo Gaagaa) i Svensk Uppfödningslöpning på Jägersro. Då tränade Sten O Jansson hästen och Torbjörn Jansson var ordinarie körsven. Efter försäljning i maj som fyraåring bröts kontakten mellan Belker och Torbjörn och den forne klassiske vinnaren har sedan dess tränats av Robert Bergh, Jean-Michel Bazire och senast Björn Goop.<br>Idag på Klosterskogen blir det återseende för Torbjörn och Belker. I februari köptes nämligen Belker till Årjängamatören Jonas Andreas Ås stall och debuten sker i Klosterskogen Grand Prix med 175.000 norska kronor till vinnaren.</p>



<figure class="wp-block-image alignright size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2018/12/belkerochbythebookml-617x333.jpg" alt="trav, travsport, sulkysport, jägersro, v75" class="wp-image-34877"/><figcaption class="wp-element-caption">Belker och Bythebook delade på segern i Svensk Uppfödningslöpning år 2018. Foto Jörgen Tufvesson/ALN</figcaption></figure>



<p>– <em>Jag fick tips av Björn Goop att Belker skulle kunna duga i Sverige och Norge om vi fick ordning på honom, hälsan har gått upp och ner för honom</em>, sade Jonas Andreas Ås till Trav- og Galopp-Nytt.</p>



<p>Tillsammans med två norrmän äger han numera Belker, som får återstifta bekantskapen med Torbjörn Jansson. Belkers senaste seger ligger så långt tillbaka i tiden som från korta E3-kvalet på Bergsåker den 4 augusti 2019. Då satt en viss Jansson i segersulkyn.<br>– <em>Det är extra roligt att Torbjörn kommer för att köra hästen. Han har många goda minnen från hästen sedan tidigare</em>, sade Ås till TGN.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/04/08v75.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Klosterskogens tävlingar idag.</a></p>



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



<p class="has-drop-cap">3 Vid sidan om Klosterskogens stortävlingar bjuder påskafton på årspremiär på Ådalens pärla Dannero (första start 12.45). Danneros säsong innehåller 15 tävlingsdagar med årsfinal den 1 oktober.</p>



<p>Den stora dagen är söndag den 6 augusti med Svenskt Kallblodskriterium och Kriteriestoet som toppnummer, men även midnattstravet på torsdagskvällen den 22 juni är en publikdragare i Ångermanland.</p>



<p>Dagens tävlingar bjuder på ett par riktiga segermaskiner i startlistorna. Jessika Sidbäcks kapable sexåring <strong>Farmpilot</strong> (e. Farmbaron) har inlett 2023 på allra bästa sätt med tre segrar på lika många starter. Fast det här med att vinna är något Farmpilot har stor vana av – elva segrar på se 16 senaste starterna talar sitt tydliga språk!</p>



<p>Dit har inte Jan Ove Olsens norska varmblod <strong>Quarter Tile </strong>(e. Muscle Hill) nått ännu, men visst är han en bit på väg. Fyra segrar och en galoppmiss har det blivit sedan hästen kom till Jan Ove Olsen i höstas efter att ha köpts för 110.000 kronor på Traveraauktion.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/04/230408.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till lördagens tävlingar.</a></p>



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



<p class="has-drop-cap">4 Elitloppsvinnaren <strong>Etonnant</strong> (e. Timoko) gör idag sin andra start för våren i semi classique-klassade Prix Kerjacques (€120.000) på Vincennes (första start 13.58) och är tveklöst det stora dagplåstret.</p>



<p><a rel="noreferrer noopener" href="https://sulkysport.se/elitloppsvinnare-i-paris-2/" target="_blank">Om det loppet kan du läsa mer här</a>, men vi konstaterar även att det är gott om svenskintresse på Parisbanan i övriga lopp.</p>



<p>I Prix de Bapaume (€53.000) för fem- och sexåringar gör <strong>Cala Mayor de B.</strong> (e. Muscle Hill) debut på fransk mark. Hon finns numera hos Christoffer Eriksson och kommer köras av Pierre Vercruysse i dagens lopp.<br>I Prix d&#8217;Aubusson (€68.000) för hästar som tjänat upp till 265.000 euro möts Jarmo Niskanens <strong>Havbergs Knight </strong>(e. Scarlet Knight) samt Eric Martinssons <strong>Dats So Cool</strong> (e. Classic Photo).</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/10/datssocool-617x333.jpg" alt="" class="wp-image-226842"/><figcaption class="wp-element-caption">Eric Martinsson-tränade Dats So Cool ska starta på Vincennes. Foto Gunilla König/Stalltz.se</figcaption></figure>



<p>I inledningsloppet Prix de la Dordogne (€62.000) startar Erik Bondo sin svenskfödda fyraårsdam <strong>Junkie</strong> (e. Varenne) mot Tomas Malmqvists danskfödda <strong>Västerbo Go Lightly </strong>(e. Västerbo Prestige) och så syns även Malmqvist Jolly Roger (e. Drole de Jet) i montéloppet Prix de Dorceau (€52.000).</p>



<p><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2023-04-08/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna på Vincennes.</a></p>



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



<p class="has-drop-cap">5 I måndags uppmärksammade vi att svenskfödde <strong>Mandela Zon</strong> (e. Maharajah) skulle följa upp lördagens stayerloppsseger på finska V75 med ett sprinterlopp i Kaustinen blott två dagar senare.<br>Även det loppet utmynnade i seger och redan idag är hästen åter tillbaka på banan då han startar i Gulddivisionsloppet Guldtäcket i Björneborg!<br>Mandela Zon har sju segrar och fyra andraplatser under årets elva starter, men nu står han inför en helt annan typ av utmaning.</p>



<p>Bland motståndarna syns bland annat Gabriella Laestanders titelförsvarare<strong> Selmer I.H. </strong>(e. Love You) som kommer till start med fyra raka segrar i bagaget, men även svenskfödde Bergsåker Winter Trot-vinnaren <strong>Hierro Boko </strong>(e. From Above) är värd ett särskilt omnämnande.</p>



<p><strong>Startlista Guldtäcket</strong><br><em>2.609 meter autostart, förstapris: 12.000 euro</em></p>



<ol class="wp-block-list">
<li>Speedy Norwegian (e. Lexus Font) – Kenneth Danielsen</li>



<li>Payet (e. Main Wise As) – Juha Utala</li>



<li>Selmer I.H. (e. Love You) – Hannu Torvinen</li>



<li>Hierro Boko (e. From Above) – Jarmo Saarela</li>



<li>Arctic Lover (e. Love You) – Antti Teivainen</li>



<li>Hazelhen Hermes (e. E L Mikko) – Tino Paldan</li>



<li>Yes Mickey (e. Muscle Hill) &#8211; Seppo Markkula</li>



<li>Mandela Zon (e. Maharajah) – Santtu Raitala</li>



<li>Consalvo (e. Ready Cash) – Ari Moilanen</li>



<li>Magical Princess (e. Maharajah) – Pekka Korpi</li>



<li>J.H.Mannerheim (e. From Above) – Olli Koivunen</li>



<li>Sahara Sandstorm (e. Make It Happen) – Ville Tonttila</li>
</ol>



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



<p class="has-drop-cap">6 Trots att fjolårets Kungapokalstvåa <strong>Power Doc </strong>(e. Muscle Massive) avslutade 1.10,7 sista varvet i gårdagens årsdebut på Sundbyholm fick han se sig besegrad.</p>



<p>Åke Lindbloms häst inledde från 40 meters tillägg och fick göra allt jobb själv under slutvarvet, men nådde aldrig ikapp Ulf Stenströmer-tränade <strong>Bold Knick</strong> (e. Bold Eagle) som anförde hela vägen.<br>Vinnaren noterades för 1.14,6/2.640 meter och Power Doc kom i mål på 1.13,5/2.680 meter.</p>



<figure class="wp-block-image alignright size-full"><img src="https://sulkysport.se/wp-content/uploads/2021/06/powerdoc2.jpg" alt="" class="wp-image-183193"/><figcaption class="wp-element-caption">Power Doc. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>I klassiska Påskbomben för fyraåringar var det Roger Walmann-tränade <strong>Wonderful Tonight </strong>(e. Magic Tonight) som plockade hem segerchecken på 60.000 kronor i lag med Torbjörn Jansson.<br>Dottern till den forne Stosprintervinnaren tillika tvåfaldiga Breeders Crown-tvåan <strong>Caddie Lisieux</strong> (e. Ready Cash) gjorde sin första start för året och fick jobba som förstahäst i andraspår de sista 700 meterna, men kunde ändå avgöra med säker marginal på 1.12,9a/1.640 meter.<br>– Konkurrenter galopperade åt alla håll och det var bara fyra hästar kvar. Jag gick ut i dödens, satte mig stilla och hon kämpade storstilat. Vi trodde mycket på den här hästen ifjol, men då räckte hon inte riktigt. Kanske att det är på väg att lossna ordentligt i år, sade Torbjörn Jansson i Sundbyholms vinnarcirkel.</p>



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



<p class="has-drop-cap">7 Är du alltjämt på jakt efter en hingst att nyttja för betäckning med ditt sto? Idag säljs tre betäckningar där överskottet går till Olle Goops Minne på Travera och det handlar om <strong>Poet Broline</strong>, <strong>Amaru Boko</strong> samt <strong>Hayden Hanover</strong>.</p>



<p>Bland starthästarna noteras även Kriterievinnaren <strong>Deimos Racing</strong> (e. Quite Easy U.S.)  halvsyster <strong>Iynx Racing</strong> (e. S.J.&#8217;s Caviar) 1.15,4m/43.800 kr som nu söker ny ägare efter att inlett karriären med en seger på de första tio starterna hos André Eklundh.</p>



<p><a href="https://www.travera.nu/kopa-hast/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens utbud på Travera.</a></p>

Fokustema
Morgonsvepet
Läs senare
Ny kung på tronen?
Om ett spännande kallblodsmöte på Klosterskogen innehållande elithästar, Etonnants andra vårstart på Vincennes samt om svenska hästar som gör upp i Guldtäcket i Björneborg går bland annat att läsa i dagens morgonsvep.
