
<p class="has-drop-cap">1 När åttaårige valacken <strong>Dallas</strong> (e. Maharajah) dundrade runt på 1.11,1a/1.640 meter på Solvalla för två veckor sedan blev Linn Strandqvists travare årets snabbaste vinnare på svensk mark. Är det dags att putsa den noteringen i kvällens snabblopp på Åby (första start 18.27)?</p>



<p>Förutsättningarna finns på förhand om vädergudarna är med, för det tio hästar starka fältet innehåller hästar som alla har rekord en bit under 1.10 och fyra ståtar dessutom med personbästa på 1.09-talet.</p>



<p>Snabbast av dem alla är Johan Untersteiner-tränade 1.09,3-travaren<strong> Heart Of Steel </strong>(e. Cantab Hall), som älskar förutsättningarna med startbil, bra spår och sprinterdistans. Med lopp i kroppen efter kort uppehåll kan det vara dags för första segern sedan början av december.</p>



<p>Övriga som travat under 1.10 är 13-årige årsdebutanten <strong>Tycoon Conway Hall</strong> (e. Conway Hall), 1.09,4ak, <strong>Harran Boko</strong> (e. Maharajah), 1.09,4ak, och <strong>Sweetman</strong> (e. Gift Kronos), 1.09,8ak.</p>



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



<p class="has-drop-cap">2 Solvalla (första start 18.15) delar kvällens V86-omgång med Åby och förutom Centaurs lopp för kallblod (läs mer nedan) så går Solvallaserien vidare med ett mkoppel segervana travare i startlistorna.</p>



<p>Fjolårets Europaderbyfinalist – vann uttagningsloppet –<strong> Nugget Zon</strong> (e. From Above) har fått ett lopp i kroppen efter vinterträning och tränaren Marcus Lindgren sitter själv upp i sulkyn bakom femåringen i högsta klassen i Solvallaserien.</p>



<figure class="wp-block-image alignright size-full"><img src="https://sulkysport.se/wp-content/uploads/2022/09/6nuggetzon3.jpg" alt="" class="wp-image-358717"/><figcaption class="wp-element-caption">Nugget Zon och Örjan Kihlström lekte hem sitt försök i Europaderbyt i höstas. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Där ställs han mot Mattias Djuses <strong>Global Classified</strong> (e. Bold Eagle), som var finalvinnare i första meetinget där han vann i klassen upp till 350.000 kronor. Nu har han klivit upp ett snäpp och kommer från tredjeplatsen i försöket där Dallas satte årsbästa i Sverige.</p>



<p>Förutom på kvällens Xpress-banor tävlas det även på Bergsåker (start 17.45) ikväll med breddlopp på menyn.</p>



<p><a rel="noreferrer noopener" href="https://sulkysport.se/wp-content/uploads/2023/03/230322.pdf" target="_blank">Här är startlistorna till onsdagens tävlingar.</a></p>



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



<p class="has-drop-cap">3 Han var Sveriges första kallblodsstjärna och den som sprängde 1.40-vallen – och han gjorde det med en gevärskula i kroppen! Historien om 1930-talets dominant <strong>Centaur</strong> (e. Elvin) är minst sagt fascinerande.<br>Ivar Lundin tränade och körde Centaur, som var uppfödd och ägs av hans pappa Jonas Arkadius Lundin från Idenor i Hälsingland. Efter en svår halsåkomma var Centaur nära att tvingas sätta livet till redan som nyfödd. Några veckor senare blev det ännu värre:<br>– <em>En dag som månadsgammalt föl låg Centaur i hagen vid sidan om mamman Centina och kunde inte resa sig. Han hade träffats av en gevärskula i bogen. Troligen en förlupen kula från en tjuvskytt. Blodet rann ur kulhålet och jag var med och bar hem Centaur</em>, berättade Ivar Lundin i boken Stjärntravare.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/03/centaur-617x429.jpg" alt="" class="wp-image-421501"/><figcaption class="wp-element-caption">1930-talets kallblodsstjärna i Sverige: Centaur. Faksimil Hästen i Sverige</figcaption></figure>



<p>Kulan hittades aldrig och Centaur tävlade hela livet med den i kroppen. Totalt gjorde han 150 starter och vann 72 av dessa. Bland vinsterna fanns dubbla svenska mästerskap och lika många triumfer i kallblodslandskampen mot Norge.</p>



<p>Den 29 april 1934 blev han historisk när han som första svenska kallblod travade under 1.40. Klockan stannade på 1.39,2/1.640 meter. Skådeplatsen var Solvalla – och ikväll hedras minnet av Centaur när han namnger ett kallblodslopp på huvudstadsbanan.</p>



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



<p class="has-drop-cap">4 Till Lisieux (första start 11.55) får idag <strong>Gaylord Am</strong> (e. Muscle Hill) bege sig för att göra sin andra start på fransk mark.</p>



<p>Vid debuten i Björn Goops regi fick hästen lämna banan lottlös, men nu jagar han revansch i Prix Larcher Publicite (€28.000) över 2.675 meter autostart och precis som i föregående start finns Tomas Malmqvists <strong>Digital Dominance</strong> (e. Super Photo Kosmos) med som en av motståndarna.</p>



<figure class="wp-block-image alignright size-full"><img src="https://sulkysport.se/wp-content/uploads/2021/07/digitaldominance.jpg" alt="" class="wp-image-185898"/><figcaption class="wp-element-caption">Digital Dominance. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Fältet innehåller ytterligare en häst med blågul koppling då Alexdandre Garreau-tränade<strong> Franklin Face </strong>(e. Chocolatier) likaså är med och strider om segerchecken på 12.600 euro.</p>



<p>Tomas Malmqvist tar med sig ytterligare en häst till Liseux i form av elvaårige<strong> Crack Atout </strong>(e. Niky) som startar i Quinté-loppet Prix Roger Ledoyen (€34.000).</p>



<p><a href="https://sulkysport.se/trav-och-galopp/lisieux-2023-03-22/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna i Lisieux.</a></p>



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



<p class="has-drop-cap">5 Kan det finnas en häftig Harper Hanovers-joker från Italien i den sexårige Love You-sonen <strong>Bixio</strong>?</p>



<p>Den frågan känns befogad att ställa efter att hästen vunnit på nytt banrekord vid fredagens tävlingar i Neapel över just &#8221;Harpers-förutsättningar&#8221;.<br>Hingsten kom nämligen i mål på 1.12,7/3.100 meter med gott om luft i lungorna och var värd betydligt mer än de 3.128 euro som han nu tjänade och som knuffade upp honom till 93.472 euro i total prissumma.</p>



<p>Karriären har innehållit 18 segrar på 51 starter och det är Nunzio Squeglia som tränar hästen som på senare tid körts av Crescenzo Maione.</p>



<p><a href="https://www.youtube.com/watch?v=rycJ8ECuTII" target="_blank" rel="noreferrer noopener">Här kan du se Bixios segerlopp från Neapel.</a></p>



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



<p class="has-drop-cap">6 Det märks att det är vår – åtminstone i almanackan – för på landets travbanor gör den ena profilhästen efter den andra årsdebut.<br>Under tisdagkvällens tävlingar i Östersund årsdebuterade Daniel Wäjersten fjolårets derbyfinalist <strong>L.A.Boko</strong> (e. Readly Express), men att avsluta 1.11,5 sista 800 meterna från femte utvändigt räckte blott till en femteplats på 1.13,8a/1.640 meter, åtta tiondelar efter segrande stallkamraten <strong>Invidia</strong> (e. Maharajah).</p>



<p>Under lunchtävlingarna på Sundbyholm gjorde även Kenneth Haugstads Breeders Crown-finalist från ifjol<strong> Landmark River</strong> (e. Propulsion) sitt första framträdande för året vilket utmynnade i en tredjeplats på 1.16,1a/2.640 meter, fem tiondelar efter segraren Thanator (e. Super Photo Kosmos).</p>



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



<p class="has-drop-cap">7 Måndagens snabblopp på Färjestad har samlat ett starkt startfält. Som tidigare nämnts i morgonsvepet så gör Sofia Aronssons stjärna <strong>Unico Broline</strong> (e. Cantab Hall) sin första start sedan andraplatsen i Silverhästen i slutet av november och Axevallatränaren luftar även nyförvärvet <strong>Mr Mah Can</strong> (e. Maharajah).</p>



<p>Därtill kryddas startfältet av Björn Goops fransyska<strong> Hirondelle Sibey</strong> (e. Gazouillis) som jagar revansch för den bleka insatsen i Sverigedebuten, 2021 års norska derbyvinnare <strong>Kräsj</strong> (e. Brillantissime) gör sin första start i Per Henriksens regi och så finns även 2020 års norska Kriterievinnare <strong>High Flyer</strong> (e. Bold Eagle) med bland de tio deltagarna.</p>



<p><strong>Startlista</strong><br><em>2.140 meter autostart, förstapris: 40.000 kr</em></p>



<ol class="wp-block-list">
<li>Ragazzo da Sopra – Carl Johan Jepson</li>



<li>Billy Idol Jet – Petter Karlsson</li>



<li>Hirondelle Sibey – Björn Goop</li>



<li>Osterc – Torbjörn Simberg</li>



<li>Order To Fly – Per Lennartsson</li>



<li>Mr Mah Can – Magnus Jakobsson</li>



<li>Kräsj – Magnus Teien Gundersen</li>



<li>High Flyer – Erlend Rennesvik</li>



<li>Test Drive – Michael Larsson</li>



<li>Unico Broline – Erik Adielsson</li>
</ol>

Fokustema
Morgonsvepet
Läs senare
Snabbast i Sverige?
Om den potentiella fartfesten på Åby, hyllningslopp för hästen som skrev historia med en gevärskula i kroppen och en potentiell joker för Harper Hanovers lopp går bland annat att läsa i veckans tredje morgonsvep.
