
<p class="has-drop-cap wp-block-paragraph">1 Eskilstunatränaren Svante Ericssons affischnamn sedan han slog igenom på allvar för några år sedan är <strong>Phoenix Photo</strong> (e. Super Photo Kosmos). Hästen kom till Svante i slutet av femåringssäsongen (!) 2019 med 1.500 kronor på kontot. Klassresan i Ericssons regi har fört upp honom till 2.216.580 kronor i prissumma och ikväll på Axevalla (första start 18.20) är det dags för årsdebut.</p>



<p class="wp-block-paragraph">Svante sitter själv i sulkyn bakom sin topptravare, som hade sitt bästa år ifjol med 1,2 miljoner insprunget, seger i silverdivisionsfinal, tredjeplats i Norrbottens Stora Pris och på höstkanten första triumfen i Gulddivisionen.<br>– <em>Han hade en tuff säsong ifjol och behövde lite återhämtning efter sista starten. Han har inte toppform direkt, men uppgiften ser passande ut och jag tror att han får ännu en fin säsong på tävlingsbanan</em>, <a rel="noreferrer noopener" href="https://cdn.travsport.se/racecards/trot/sport/600732.pdf" target="_blank">säger Svante Ericsson i en intervju i Axevallaprogrammet.</a></p>



<p class="wp-block-paragraph">Något dukat bord kommer han dock inte till i årsdebuten, där rikstotohärdade hästar som <strong>Mr Mah Can</strong> (e. Maharajah), <strong>Full Of Muscles</strong> (e. Muscle Mass) och <strong>Behind Bars</strong> (e. Maharajah) står för motståndet tillsammans med 2021 års Suur-Hollola Ajo-tvåa <strong>Mas Capacity </strong>(e. Conway Hall), som gör första starten sedan juli förra året.</p>



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



<p class="has-drop-cap wp-block-paragraph">2 Tisdagen inleds med lunchtävlingar på Dannero (start 12.20), där Jan Ove Olsens kapable valack <strong>Mizai</strong> (e. Donato Hanover) är tillbaka på banan efter att ha fått strykas för feber från en tilltänkt start på Solvalla för knappt tre veckor sedan.</p>



<p class="wp-block-paragraph">Mizai hade ett starkt år 2022 med sex segrar och drygt 450.000 kronor insprunget. I STL-sammanhang vann han försök i klass I, men väntar efter två starter i år på första årssegern. Kanske är det dags idag?</p>



<p class="wp-block-paragraph">Eskilstuna (första start 17.45) kompletterar kvällsutbudet och Jörgen Westholm tar ut treåriga <strong>Graces Bird </strong>(e. Bird Parker). Stoet debuterade på urstarka 1.15,3/2.140 meter voltstart på Solvalla i mitten av april, men fick ändå nöja sig med andraplatsen bakom spetsvinnaren <strong>Selfmade Tile</strong> (e. Walner). För motståndet i kvällens lopp står bland annat två andra treåringar, som travat 1.15-tider i voltstart: Roger Walmanns <strong>Flotilla</strong> (e. Readly Express) och Svante Ericssons <strong>Gooding B.T.B.</strong> (e. Explosive Matter).</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/05/230509.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till tisdagens tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">3 Han var mannen bakom stjärnhästar som Big Spender, Song Key, Prince R.S, Gissle, Al Joe och många fler. På lördag hyllas Berth Johansson, som avled midsommarhelgen 2009, i en ålder av 76 år.<br>Berth var elva år när travbanan i Umeå öppnade 1944 och blev tidigt indragen i travsportens spännande värld via sin pappa Ragnar. I ett reportage i Travrondens Vinternummer 2001 berättade Berth om hur fascinerad han blev när han kom i kontakt med varmblodstravare (pappa Ragnar handlade, och höll på med, kallblod och nordsvenskar) via hästhandlaren Harald Duvkloo som tog hästar söderifrån till Norrland:<br>”<em>Jag hade börjat läsa in mig på varmblodsstamboken och en gång hade Duvkloo med sig ett fint varmbod som gått på Åby. Hästen var efter Sir Walter Scott och Etta Hanover. Jag gick på pappa om att den där måste vi försöka köpa. Medan hästen gick ett lopp haglade buden runt Duvkloo. Pappa bjöd 1.800. Duvkloo skulle ha 2 100. När hästen var i sista kurvan sa pappa, ”nå, 1.850 då”. Topp svarade Duvkloo och så slog de i händerna så där som man gjorde för att bekräfta hästaffärer på den tiden</em>”.<br>Det var Juan Walter som Berth nyss förmått sin pappa att köpa. Innan karriären var över hade Juan Walter tagit 27 segrar på 171 starter och sprungit in 47.000 kronor. Mer än 20 gånger inköpspriset.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/09/bigspenderjohanssonberth85.-617x415.jpg" alt="" class="wp-image-206809"/><figcaption class="wp-element-caption">Big Spender och Berth Johansson vann Derbyt 1985. Över 14.000 personer på plats. Foto Stefan Melander/Stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Berth Johansson var amatör fram till 1979 då han äntligen blev proffs. Han hade aldrig större stall än ett 20-tal hästar och lade ner mycket tid och omsorg på varje individ. Berth gjorde det till en sport att utveckla, göra segermaskiner, av äldre hästar som gärna fick ha enkel bakgrund. Hans största stjärna blev Big Spender, vilken som treåring var ansedd som en av Solvallas absolut mot talangfulla hästar i 1981-kullen, men som hade halsproblem. Hos Berth blev Big Spender både Derbyvinnare och en stor äldrestjärna.<br>Sammanlagt landade Berth på 1.709 kusksegrar och han blev champion på hemmabanan 14 gånger åren 1958–1988.<br>Sedan 2010 har hans minneslopp avgjorts på Umåker och vinnaren i lördagens upplaga skriver in sig i ett mycket fint sällskap.</p>



<p class="wp-block-paragraph"><a rel="noreferrer noopener" href="https://sulkysport.se/wp-content/uploads/2023/05/13v75.pdf" target="_blank">Här kan du ta del av startlistor till </a><a rel="noreferrer noopener" href="https://sulkysport.se/wp-content/uploads/2023/05/13v75.pdf" target="_blank">l</a><a rel="noreferrer noopener" href="https://sulkysport.se/wp-content/uploads/2023/05/13v75.pdf" target="_blank">ö</a><a rel="noreferrer noopener" href="https://sulkysport.se/wp-content/uploads/2023/05/13v75.pdf" target="_blank">r</a><a rel="noreferrer noopener" href="https://sulkysport.se/wp-content/uploads/2023/05/13v75.pdf" target="_blank">d</a><a rel="noreferrer noopener" href="https://sulkysport.se/wp-content/uploads/2023/05/13v75.pdf" target="_blank">a</a><a rel="noreferrer noopener" href="https://sulkysport.se/wp-content/uploads/2023/05/13v75.pdf" target="_blank">g</a><a rel="noreferrer noopener" href="https://sulkysport.se/wp-content/uploads/2023/05/13v75.pdf" target="_blank">e</a><a rel="noreferrer noopener" href="https://sulkysport.se/wp-content/uploads/2023/05/13v75.pdf" target="_blank">n</a><a rel="noreferrer noopener" href="https://sulkysport.se/wp-content/uploads/2023/05/13v75.pdf" target="_blank">s</a><a rel="noreferrer noopener" href="https://sulkysport.se/wp-content/uploads/2023/05/13v75.pdf" target="_blank"> </a><a rel="noreferrer noopener" href="https://sulkysport.se/wp-content/uploads/2023/05/13v75.pdf" target="_blank">t</a><a rel="noreferrer noopener" href="https://sulkysport.se/wp-content/uploads/2023/05/13v75.pdf" target="_blank">ä</a><a rel="noreferrer noopener" href="https://sulkysport.se/wp-content/uploads/2023/05/13v75.pdf" target="_blank">v</a><a rel="noreferrer noopener" href="https://sulkysport.se/wp-content/uploads/2023/05/13v75.pdf" target="_blank">l</a><a rel="noreferrer noopener" href="https://sulkysport.se/wp-content/uploads/2023/05/13v75.pdf" target="_blank">i</a><a rel="noreferrer noopener" href="https://sulkysport.se/wp-content/uploads/2023/05/13v75.pdf" target="_blank">n</a><a rel="noreferrer noopener" href="https://sulkysport.se/wp-content/uploads/2023/05/13v75.pdf" target="_blank">g</a><a rel="noreferrer noopener" href="https://sulkysport.se/wp-content/uploads/2023/05/13v75.pdf" target="_blank">a</a><a href="https://sulkysport.se/wp-content/uploads/2023/05/13v75.pdf" target="_blank" rel="noreferrer noopener">r</a><a rel="noreferrer noopener" href="https://sulkysport.se/wp-content/uploads/2023/05/13v75.pdf" target="_blank"> på Umåker.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4 Elitloppshelgen närmar sig med stormsteg och allt fler hästar som är aktuella för framträdande i de olika loppen på Solvalla gör denna vecka sina genrep inför vad som komma skall.<br>En sådan häst syns på den norska nationalarenan Bjerke i Oslo. Anette Midtlyngs <strong>Patrick Palema</strong> (e. Muscle Hill) övertygade då han vann ett Klass II-försök på Momarken den 18 mars och har därefter varit tvåa i V75-lopp på Klosterskogen under påskhelgen bakom Jörgen S Erikssons Frazze (e. Mosaique Face).</p>



<p class="wp-block-paragraph">Ikväll stöter fyraåringen på Frode Hamres segervana duo <strong>Broadway Don</strong> (e. Donato Hanover) samt <strong>Thai Targaryan</strong> (e. Muscle Hill) i strid om 30.000 norska kronor i detta lopp som körs över 2.100 meter autostart med sju deltagare och som vanligt är det Erlend Rennesvik som sköter tömföringen.</p>



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



<p class="has-drop-cap wp-block-paragraph">5 Det är Tomas Malmqvist som försvarar de svenska färgerna vid dagens tävlingar på Vincennes (16.25).</p>



<p class="wp-block-paragraph">Jägersrotränaren startar en trio och inleder med svenskfödde <strong>Devs Definitif</strong> (e. Infinitif) i sadelloppet Prix Hersilia (€52.000) vilken rids av Adrien Lamy.<br>Därefter startar treårige <strong>Kobayashi</strong> (e. Face Time Bourbon) i Prix de Mamers (€46.000) tillsammans med Cédric Parys medan jämngamla <strong>Kelina Josselyn</strong> (e. Face Time Bourbon) körs av Eric Raffin i Prix Anahita (€46.000).</p>



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



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/06/devsdefinitifmadh220607adamstromstalltz-617x386.jpg" alt="" class="wp-image-312655"/><figcaption class="wp-element-caption">Devs Definitif. Foto: Adam Ström/stalltz.se</figcaption></figure>



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



<p class="has-drop-cap wp-block-paragraph">6 Alessandro Gocciadoro visade i upp en fin fyraåring vid söndagens tävlingar på Vermo då<strong> </strong><a href="https://sulkysport.se/toppspurt-av-denver-gio/" target="_blank" rel="noreferrer noopener"><strong>Denver Gio</strong> (e. Southwind Frank) vann Glenn Kosmos Memorial </a>och har nu fyllt på med ytterligare två spännande namn i samma kull.</p>



<p class="wp-block-paragraph">Det franskfödda stoet <strong>Jet Set Bond</strong> (e. Prodigious) 1.11,9/€151.670 som vunnit Grupp III-loppet Prix Marcel Dejean (€60.000) och tagit två tredjeplatser i semi classique-lopp samt slutat sexa i Europeiskt Treåringschampionat (€100.000) är ny hos italienaren efter att hon vunnit tre av sina 28 första starter i karriären hos Jean-Michel Bazire.</p>



<p class="wp-block-paragraph">Från Enrico Belleis stall har även det jämngamla stoet <strong>Doroty degli Dei</strong> (e. Donato Hanover) 1.12,1/€38.332 anslutit.<br>Ifjol vann hon ett uttagningslopp till Oaks del Trotto, men slutade &#8221;bara&#8221; sjua i finalen och har haft en kämpig inledning på fyraåringssäsongen.</p>



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



<p class="has-drop-cap wp-block-paragraph">7 Det är stjärntätt i lördagens &#8221;guldlopp&#8221; på norska Biri när tio hästar gör upp om segerchecken på 70.000 norska kronor.</p>



<p class="wp-block-paragraph">Frode Hamre har fått meriterade, franska hästar på löpande band under de senaste åren och startar inte mindre än en trio i detta lopp över 2.100 meter autostart.<br><strong>Ble du Gers </strong>(e. Quinoa du Gers) och <strong>Feydeau Seven</strong> (e. Redeo Josselyn) har hunnit visa upp sig sedan tidigare medan euromiljonären <strong>Dorgos de Guez</strong> (e. Romcok de Guez) gör debut på norsk mark.<br>Tioåringen som vann Prix de Luxembourg (€100.000) år 2021 var även tvåa bakom Elitloppsvinnaren Etonnant (e. Timoko) i fjolårets Prix d&#8217;Ete (€200.000) och häftigt meriterad för sammanhanget.<br>I samma lopp gör fjolårets klassklättrare <strong>Best Ofdream Trio </strong>(e. Nad Al Sheba) årsdebut i regi Erik Killingmo och Kim Eriksson gör resan över gränsen för att köra sexåringen.</p>



<p class="wp-block-paragraph"><strong>Startlista</strong><br><em>2.100 meter autostart, förstapris: 70.000 norska kronor</em></p>



<ol class="wp-block-list">
<li>High Glider – Lars Anvar Kolle</li>



<li>Feydeau Seven – Magnus Teien Gundersen</li>



<li>Golden Dream M.E. – Noralf Braekken</li>



<li>Ble du Gers – Per Oleg Midtfjeld</li>



<li>Best Ofdream Trio – Kim Eriksson</li>



<li>Gretzky B.R. – Geir Vegard Gundersen</li>



<li>Park View – Vidar Hop</li>



<li>Always On Time – Tom Erik Solberg</li>



<li>Iggy B.R. – Eirik Höitomt</li>



<li>Dorgos de Guez – Åsbjörn Tengsareid</li>
</ol>

Fokustema
Morgonsvepet
Läs senare
Guldvinnare i årsdebut
Om en Gulddivisionsvinnare som gör årsdebut på Axevalla, en norsk Klass II-vinnare som genrepar inför stundande final på Bjerke samt om Tomas Malmqvists trippla chanser på Vincennes går bland annat att läsa i dagens morgonsvep.
