Aún no hay reacciones. ¡Sé el primero! <p align="center">&nbsp;</p>
<p align="center"><span style="font-size: 18px;"><strong>Tras las huellas de nuestros or&iacute;genes</strong></span></p>
<p align="center"><span style="font-size: 18px;"><strong>Salvador Delgado Su&aacute;rez</strong></span></p>
<p align="center"><span style="font-size: 18px;"><strong>"Boro"</strong></span></p>
<p align="center">&nbsp;</p>
<p align="center">&nbsp;</p>
<p align="center"><span style="font-size: 14px;"><strong><em>A la mar voy todav&iacute;a</em></strong></span></p>
<p>&nbsp;</p>
<p>La paz te he suplicado y me la niegas.</p>
<p>Mi ternura te ofrezco y no&nbsp; la quieres.</p>
<p>Pero algo he de decirte todav&iacute;a;</p>
<p>Que no hagas naufragar a mi palabra</p>
<p>Ni apagar el amor que la mantiene.</p>
<p>&nbsp;</p>
<p>(Pedro Garc&iacute;a Cabrera).</p>
<p align="right">&nbsp;</p>
<p align="center"><strong style="font-size: 14px; line-height: 1.4; text-align: left;"><em>A Pesar De Los Vientos</em></strong></p>
<p align="center">&nbsp;</p>
<p><span style="line-height: 1.4;">&nbsp;Con este t&iacute;tulo recogido de un verso de Luis de G&oacute;ngora, se ha editado recientemente la obra completa del poeta y amigo Manuel Gonz&aacute;lez Sosa, vecino de la muy&nbsp; ilustre ciudad de Gu&iacute;a.</span></p>
<p>No muy lejos del frondoso y buc&oacute;lico lugar donde descansan los restos del insigne escritor gu&iacute;ense, en un barrio humilde de pescadores y lugare&ntilde;os dedicados a las faenas agr&iacute;colas, conocido como La Monta&ntilde;a, en la calle Princesa Mesaquera n&uacute;mero 27, el matrimonio integrado por Florencio Delgado y Mar&iacute;a Del Pino Su&aacute;rez ver&iacute;an un 30 de octubre de 1924 cumplidos sus sue&ntilde;os felizmente, al producirse el nacimiento de su peque&ntilde;o v&aacute;stago, al que pusieron por nombre Salvador Delgado Su&aacute;rez, aunque desde su m&aacute;s tierna infancia ser&iacute;a conocido por Boro, sobrenombre que le ha acompa&ntilde;ado toda su vida.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_111128161.jpg" /></p>
<p><em>Panor&aacute;mica de la monta&ntilde;a de G&aacute;ldar en la d&eacute;cada de los a&ntilde;os treinta.</em></p>
<p><span style="line-height: 1.4;">De extracci&oacute;n rural, sus primeros a&ntilde;os transcurrieron en una especie de "locus amoenus" horaciano, una arcadia feliz donde las horas transcurr&iacute;an lentas y placenteras.</span></p>
<p>Las adustas y tortuosas veredas en los centelleantes veranos solariegos bajo el cielo azul de la infancia, se tornaban en nubes de roc&iacute;o al reverdecer con las lluvias de los g&eacute;lidos inviernos, dotando al paisaje de diferentes tonos crom&aacute;ticos y peculiar aroma.</p>
<p>En aquellos a&ntilde;os de penuria y cartillas de racionamiento &ndash;motivados por la contienda civil- apenas transitaban coches en la ciudad de G&aacute;ldar, que al pertenecer a familias acaudaladas eran conocidos en todo el vecindario.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_111128352.jpg" /></p>
<p><em>Iglesia de Santiago Ap&oacute;stol en la ciudad de G&aacute;ldar.</em></p>
<p>La mayor parte de los pueblos perif&eacute;ricos en torno al n&uacute;cleo principal de la plaza mayor, formaban parte de su enigm&aacute;tica monta&ntilde;a, de color rojizo crepuscular, rodeada de caminos pedregosos, lomas y veredas de eucaliptos, solares despoblados y enormes extensiones de fincas de cultivo de plataneras y ganader&iacute;a, separadas por altos muros de piedras bordeando barrancos que desembocaban al mar.</p>
<p>La vida transcurr&iacute;a con apacible naturalidad y a pesar de las penurias y necesidades de aquellos a&ntilde;os, sus gentes eran amables y solidarias, haciendo causa com&uacute;n en todas las vicisitudes que el d&iacute;a a d&iacute;a les pod&iacute;a deparar.</p>
<p>Salvador Delgado (Boro) cuando a duras penas lograba mantenerse en pi&eacute;, ya comenzaba a golpear con deleite y fruici&oacute;n aquellas pelotas confeccionadas con tiras de plataneras en un rec&oacute;ndito e ignoto paraje conocido como Callej&oacute;n del Pilar.</p>
<p><strong style="font-size: 14px; line-height: 1.4;">Una barca de remos esperaba en Caleta de Arriba.</strong></p>
<p><span style="line-height: 1.4;">Su progenitor se dedicaba a la pesca en toda la costa norte, preferentemente en Agaete y Sardina.</span></p>
<p>Sus estudios, como la mayor&iacute;a de familias humildes en aquellos a&ntilde;os, eran primarios, hasta que a la corta edad de 10 a&ntilde;os, debido a imperiosas necesidades familiares, comenzar&iacute;a sus temerosas aventuras en las faenas del mar:</p>
<p>Se levantaban a&uacute;n sin dar el alba y acompa&ntilde;&aacute;ndose de farolas en la fr&iacute;a noche abandonaban su humilde hogar.</p>
<p>En el silencio de las calles el ruido de los pasos tiene una presencia prominente.</p>
<p>En el campo una leve neblina vaporosa flota sobre la tierra h&uacute;meda, pasando a trav&eacute;s de acequias que fluyen y estanques dormidos. El aire al pasar por la arboleda produce un susurro voluptuoso.</p>
<p>A la luz de las farolas las peque&ntilde;as gotas del roc&iacute;o brillan en las briznas vegetales como sombras en la opacidad de la noche,&nbsp; bajando con sigilo las empedradas calles del barrio y los polvorientos senderos, atravesando fincas y barrancos de ca&ntilde;a y maleza, hasta llegar a un paradisiaco lugar conocido como Caleta de Arriba donde les aguardaba un bote de remos.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_111128523.jpg" /></p>
<p><em>Un bote de remos esperaba en Caleta de Arriba.</em></p>
<p>Aquella peque&ntilde;a embarcaci&oacute;n representaba su &uacute;nico y m&aacute;s preciado sustento.</p>
<p>Muchos pescadores sol&iacute;an afirmar que en aquella zona de G&aacute;ldar se pod&iacute;a encontrar el mejor pescado. Y as&iacute; era en ocasiones. Sin embargo, no siempre&nbsp; les sonre&iacute;a la fortuna y pod&iacute;an producirse inesperados giros del destino, vi&eacute;ndose obligados a faenar mar adentro entre impetuosos vendavales, soportando peligrosas y turbulentas mareas donde muchos pescadores hab&iacute;an perdido sus vidas.</p>
<p><span style="line-height: 1.4;">Por los confines del mar flotaba una tenebrosa niebla.</span></p>
<p><span style="line-height: 1.4;">No se o&iacute;a sino el sonar de los remos en el agua; el ruido tenue de las olas contra la embarcaci&oacute;n que se alzaba a lo alto en la penumbra en direcci&oacute;n a lo desconocido y misterioso</span></p>
<p><strong style="font-size: 14px; line-height: 1.4;">En recuerdo de D. Jos&eacute; De Aguilar D&iacute;az.</strong></p>
<p><span style="line-height: 1.4;">En ocasiones, al declinar el d&iacute;a, a&uacute;n le quedaban fuerzas para trabajar en la construcci&oacute;n del Campo de Barrial o en las extensas fanegadas de plataneras del industrial D. Jos&eacute; De Aguilar D&iacute;az, que hab&iacute;a sido presidente del Marino y padre del otrora m&aacute;ximo dirigente amarillo D. Jos&eacute; De Aguilar Hern&aacute;ndez.</span></p>
<p><span style="line-height: 1.4;"><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_111129184.jpg" /></span></p>
<p><em>Finca de plataneras de D. Jos&eacute; De Aguilar D&iacute;az .</em></p>
<p>&nbsp;</p>
<p><em><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_11112948josok.jpg" width="393" height="589" /></em></p>
<p><em>D. Jos&eacute; De Aguilar D&iacute;az.</em></p>
<p>Nuestro protagonista no repara en elogios hacia el reputado empresario:</p>
<p>"D. Jos&eacute; De Aguilar &ndash;padre- era un gran aficionado al f&uacute;tbol y aunque marinista de pro, siempre me dio toda clase de facilidades a efectos de poder compaginar mi horario laboral con los entrenamientos. Eternamente tendr&eacute; adquirida una deuda de gratitud hacia este gran caballero del deporte.</p>
<p>Era una persona que te dispensaba un trato excepcional y de una generosidad inusual".</p>
<p><strong style="font-size: 14px; line-height: 1.4;">Aquellos inolvidables encuentros de los clubes hist&oacute;ricos. El Marino vence al Victoria en hom&eacute;rica gesta</strong></p>
<p><span style="line-height: 1.4;">En edad infantil comienza a jugar al f&uacute;tbol con los ni&ntilde;os de su barrio de La Monta&ntilde;a. Eran partidos no federados que se disputaban principalmente en los solares y estanques de barro de la localidad; terrenos desnivelados y agrietados por la sequedad, que se convert&iacute;an en aut&eacute;nticos lodazales con la llegada de las lluvias invernales.</span></p>
<p><span style="line-height: 1.4;"><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_111130105.jpg" /></span></p>
<p><span style="line-height: 1.4;"><em>Instant&aacute;nea de la ciudad de G&aacute;ldar.</em></span></p>
<p>Teniendo en cuenta su corta edad llamaba la atenci&oacute;n su gran altura y complexi&oacute;n f&iacute;sica, muy superior a los dem&aacute;s ni&ntilde;os de su generaci&oacute;n, circunstancia que le hac&iacute;a destacar en todos los campos de la zona norte.</p>
<p>Cuando el Estadio de Barrial era un simple terreno no acotado y sin grader&iacute;o en la d&eacute;cada de los a&ntilde;os 30 del pasado siglo, sol&iacute;a acudir de la mano de su padre, D. Florencio, a presenciar los campeonatos amistosos que se organizaban en honor a la festividad del ap&oacute;stol Santiago, donde sol&iacute;an formar parte del cartel la mayor&iacute;a de clubes legendarios como el RC Victoria, Marino CF, CD Gran Canaria, Porte&ntilde;o, Santa Catalina&hellip;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_111130346_result.jpg" /></p>
<p><em>Formaci&oacute;n del RC Victoria en la d&eacute;cada de los treinta.</em></p>
<p>&nbsp;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_111131137_result.jpg" /></p>
<p><em>Equipo del Marino formando en el Campo Espa&ntilde;a en los a&ntilde;os treinta.</em></p>
<p>Aquellos apasionantes encuentros han quedado en la memoria viva y colectiva de todos los galdenses, confrontaciones &eacute;picas que ya han sido narradas con gran rigurosidad y belleza descriptiva por el fallecido ex cronista de la ciudad de Las Palmas de Gran Canaria D. Francisco Garc&iacute;a, conocido en el mundo period&iacute;stico como Mart&iacute;n Moreno.</p>
<p>Nuestro entrevistado, a pesar de los a&ntilde;os transcurridos, rememora aquellos encuentros con una memoria prodigiosa:</p>
<p>"Los jugadores que pertenecieron a las primeras &eacute;pocas del f&uacute;tbol canario eran aut&eacute;nticos h&eacute;roes. &iexcl;Hab&iacute;a que ver el ardor que pon&iacute;an en la lucha teniendo en cuenta que eran partidos amistosos y la destreza y habilidad que ten&iacute;an con el bal&oacute;n!</p>
<p>A&uacute;n recuerdo un encuentro donde el Marino venci&oacute; al Victoria con todos los honores.</p>
<p>La mayor&iacute;a de aquellos jugadores trabajaban en condiciones infrahumanas y viv&iacute;an en el umbral de la pobreza, pero una vez en el campo se produc&iacute;a en ellos una metamorfosis que a&uacute;n no acierto a comprender. Puede ser, quiz&aacute;s, que cuando eres un ni&ntilde;o todo lo magnificas pero nunca he visto nada semejante.</p>
<p>En cuanto a lo de Mart&iacute;n Moreno, tanto &eacute;l como su familia eran nativos de la ciudad de G&aacute;ldar. Sus padres regentaban una fonda cerca de la plaza mayor y por esta circunstancia era conocido como "Paco el de La Fonda".</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_111131348_result.jpg" width="337" height="520" /></p>
<p><em>Mart&iacute;n Moreno.</em></p>
<p>Era igualmente un gran aficionado al f&uacute;tbol y desde muy joven ya era corresponsal de todos los acontecimientos deportivos que ten&iacute;an lugar en la zona del Noroeste. Con posterioridad, compaginar&iacute;a sus labores period&iacute;sticas con su mete&oacute;rica carrera militar y sus grandes aficiones: el arte cinematogr&aacute;fico y el teatro costumbrista".</p>
<p><strong style="font-size: 14px; line-height: 1.4;">De portador de un humilde saco de material deportivo a figura emergente del f&uacute;tbol local.</strong></p>
<p><span style="line-height: 1.4;">El tiempo seguir&iacute;a su inevitable curso y ya Boro descollaba como una gran promesa de la cantera en la Ciudad de los Caballeros.</span></p>
<p>Dado que varios miembros de su familia integraban la disciplina del Galdense, nuestra joven promesa ard&iacute;a en deseos de formar igualmente en el equipo de su localidad, anhelo que no hab&iacute;a podido cumplir, al existir una circular que establec&iacute;a unos c&aacute;nones y l&iacute;mites de edad.</p>
<p>Un buen d&iacute;a no pudo comparecer al entrenamiento el&nbsp; encargado del material, que hac&iacute;a las veces de utillero y portaba con paciencia benedictina un pesado saco que requer&iacute;a la ayuda de varios componentes del equipo en el tr&aacute;nsito hacia el terreno de juego.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_111132479-a_result.jpg" width="515" height="386" /></p>
<p><em>Material deportivo.</em></p>
<p>Boro revive aquella incomparecencia como una de las circunstancias m&aacute;s cruciales en su carrera deportiva:</p>
<p>"El hecho de ofrecerme voluntariamente a transportar la pesada carga del material origin&oacute; que en el transcurso del partidillo, se lesionara un componente del equipo y yo ocupara su demarcaci&oacute;n, aunque s&oacute;lo fuera para hacer n&uacute;mero. Sin embargo, aquel d&iacute;a parec&iacute;a estar en estado de gracia; mi inspiraci&oacute;n era tal que todo me sonre&iacute;a causando admiraci&oacute;n en todos los presentes que no comprend&iacute;an c&oacute;mo un ni&ntilde;o pod&iacute;a aventajar en el juego y condiciones f&iacute;sicas a jugadores experimentados que me doblaban la edad.</p>
<p>Al final del encuentro todos mis compa&ntilde;eros, entre ellos mis propios hermanos y el t&eacute;cnico, vinieron a felicitarme efusivamente, haci&eacute;ndome saber que a partir de aquel d&iacute;a ser&iacute;a un asiduo a todos los entrenamientos. Desde esa fecha comenzaron a llamarme por el sobrenombre de "El Ni&ntilde;o", al igual que ya hab&iacute;an hecho con Luis Molowny en el Marino CF.</p>
<p>Recuerdo que cuando llegu&eacute; a mi domicilio en compa&ntilde;&iacute;a de mis hermanos dije una frase que suelo comentar con relativa frecuencia a mis hijos y entre compa&ntilde;eros: &iexcl;A partir de este d&iacute;a jam&aacute;s volver&eacute; a cargar con el pesado saco de material!</p>
<p>Paralelamente segu&iacute;a jugando con el equipo de mi barrio de La Monta&ntilde;a, que ten&iacute;a la denominaci&oacute;n de Nueva Espa&ntilde;a".</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_111133519-b_result.jpg" /></p>
<p><em>Equipo del Nueva Espa&ntilde;a en el Campo de los Albercoles.</em></p>
<p><em style="line-height: 1.4;">De pi&eacute;, de izquierda a derecha: Miguel Delgado, Crist&oacute;bal Saavedra, Pedro Vega, Ignacio Rodr&iacute;guez, Salvador Delgado, Juan Gonz&aacute;lez, Jos&eacute; Delgado, Manolo Cubas y Esteban Mart&iacute;n.</em></p>
<p><em style="line-height: 1.4;">Sentados: Domingo Su&aacute;rez, Juan Antonio yJuan Delgado</em></p>
<p>&nbsp;</p>
<p><strong style="font-size: 14px; line-height: 1.4;">La confrontaci&oacute;n con el legendario Tirma, las palomas mensajeras y la promesa al ap&oacute;stol Santiago.</strong></p>
<p><span style="line-height: 1.4;">No llegaba Boro a la edad de 15 a&ntilde;os y a pesar de las rigurosas normas federativas, los m&aacute;ximos mandatarios del club galdense, ampar&aacute;ndose en la madurez y corpulencia del jugador que aparentaba m&aacute;s edad de la real, se las ingeniaron para falsificar la ficha a efectos de que pudiera participar en una categor&iacute;a superior.</span></p>
<p>Desde muy pronto, se convertir&iacute;a en el elemento m&aacute;s destacado del equipo juvenil alternando los entrenamientos con la primera plantilla.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111342110_result.jpg" width="475" height="366" /></p>
<p><em>Federaci&oacute;n Canaria de F&uacute;tbol en el a&ntilde;o 1934.</em></p>
<p>Salvador Delgado "Boro" nos narra c&oacute;mo una tarde, la reca&iacute;da de un jugador, dar&iacute;a un giro copernicano al rumbo de los hechos:</p>
<p>"Durante el entrenamiento vespertino de los jueves, donde sol&iacute;amos jugar un partidillo con el primer equipo, el se&ntilde;or Molinos, que era por aquel entonces entrenador del juvenil, me llam&oacute; aparte y con voz grave y en&eacute;rgica, mir&aacute;ndome fijamente me dijo: "Tiene que irse usted preparando. El club ha acordado que ha llegado su momento y aunque tengamos que falsificar de nuevo su ficha, es importante su concurso. Como usted tendr&aacute; conocimiento, el pr&oacute;ximo domingo va a tener lugar el encuentro m&aacute;s importante de la temporada y usted tiene muchas posibilidades de integrar la alineaci&oacute;n titular".</p>
<p>Durante la noche, en la soledad de su hogar de La Monta&ntilde;a, Boro no pudo conciliar el sue&ntilde;o. Aquel esperado d&iacute;a ten&iacute;a visos de acontecimiento en toda la zona del noroeste. Llegaba al terreno de Los Albercoles, su m&aacute;s enconado rival y este legendario conjunto no pod&iacute;a ser otro que el de las camisetas rojas del Tirma, club de elevado historial, m&aacute;ximo representante del municipio de Gu&iacute;a que hab&iacute;a implantado su hegemon&iacute;a futbol&iacute;stica en la zona norte de la isla.</p>
<p>Aquella noche, previa al trascendental encuentro, entremezclada de insomnio y tortuosas pesadillas, Boro cree escuchar la voz del ap&oacute;stol Santiago en la lejan&iacute;a. Era como una epifan&iacute;a que se le mostraba centelleante en su m&aacute;s absoluta dimensi&oacute;n, &nbsp;infund&aacute;ndole &aacute;nimos, serenidad y confianza en el triunfo. Al despertar, a&uacute;n sin dar los claros del d&iacute;a, nuestra joven promesa toma conciencia de la realidad: "Todo hab&iacute;a sido un feliz sue&ntilde;o en su imaginaci&oacute;n.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111344811.jpg" width="413" height="476" /></p>
<p><em>Imagen de Santiago Ap&oacute;stol de la ciudad de G&aacute;ldar.</em></p>
<p>Aquel nublado d&iacute;a festivo, el terreno de juego presentaba un lleno apote&oacute;sico. El encuentro estaba rodeado de una gran expectaci&oacute;n. Era adem&aacute;s de gran rivalidad y trascendencia en la clasificaci&oacute;n. Nuestro&nbsp; joven debutante no hab&iacute;a llegado hasta la c&uacute;spide, tras enormes vicisitudes y sacrificios, para perder su gran oportunidad.</p>
<p>La prolongada ovaci&oacute;n que recibieron los dos equipos de sus seguidores ser&iacute;a abrumadora, haciendo estremecer al joven jugador que nunca hab&iacute;a experimentado un ambiente tan exultante.</p>
<p>En aquel mismo instante &ndash;suele comentar con frecuencia nuestro protagonista- como pose&iacute;do de una fuerza sobrenatural, acord&aacute;ndose de la revelaci&oacute;n en sue&ntilde;os de la figura del ap&oacute;stol Santiago y sus palabras de aliento, Boro parec&iacute;a haberse transfigurado en un jugador omnipresente en la medular de su equipo. Su actuaci&oacute;n fue inconmensurable asombrando a propios y extra&ntilde;os con sus portentosas cualidades f&iacute;sicas y t&eacute;cnica depurada.</p>
<p>La hinchada numerosa del Tirma &ndash;equipo campe&oacute;n varias temporadas consecutivas- se preguntaba con extra&ntilde;eza y perplejidad de d&oacute;nde hab&iacute;a salido aquel ni&ntilde;o de tan buenas hechuras.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111352112-a_result.jpg" width="445" height="288" /></p>
<p><em>Formaci&oacute;n del Tirma.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111360612-b_result.jpg" width="502" height="337" /></p>
<p><em>Salvador Delgado (Boro) formando con el Galdense.&nbsp;</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111371413-a-.jpg" width="510" height="355" /></p>
<p><em>Cinco jugadores del Tirma que hicieron historia. De izquierda a derecha: Cirivella, Pepito Caballero, Jos&eacute; Manuel, Mart&iacute;n Est&eacute;vez y Manolo Armas.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111374013-b_result.jpg" width="398" height="597" /></p>
<p><em>Salvador Delgado (Boro) con una bella simpatizante del Galdense en el Estadio de Barrial.</em></p>
<p>&nbsp;</p>
<p>Santiago Gil Cabrera, directivo del Tirma por aquellos a&ntilde;os e industrial relevante en la zona norte en la rama de vinos y quesos de Gu&iacute;a, profesi&oacute;n que heredar&iacute;a con posterioridad su hijo Santiago, convirtiendo su local a la entrada del municipio en verdadero lugar de referencia y en una de las mayores se&ntilde;a de identidad de la ciudad, era uno de los testigos de excepci&oacute;n aquella tarde en el terreno de Los Albercoles.</p>
<p>Se daba la circunstancia que el Gu&iacute;a hab&iacute;a infringido una severa derrota al Galdense en el Stadium 14 de Abril del municipio gu&iacute;ense en la primera vuelta.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111381414.jpg" width="309" height="427" /></p>
<p><em>Santiago Gil (hijo).</em></p>
<p>Santiago Gil era un experto colomb&oacute;filo adem&aacute;s de poseer uno de los mejores palomares de la vecindad con centenares de aves viajeras de irrefutable calidad.</p>
<p>En los d&iacute;as que su equipo jugaba como visitante, ten&iacute;a como norma llevarse al recinto deportivo una docena de ellas perfectamente anilladas y en breves notas ir redactando las incidencias claves de los encuentros de su equipo con la finalidad de que llegaran a su palomar de la ciudad de Gu&iacute;a donde su hijo Santiago las recib&iacute;a con inusitada algarab&iacute;a. Una vez llegaban al palomar, las noticias eran le&iacute;das a viva voz desde la azotea a los centenares de ciudadanos que se agolpaban en su domicilio que daba a las calles Marqu&eacute;s de Munich y M&eacute;dico Est&eacute;vez.</p>
<p>Cuando las palomas iban retomando su &uacute;ltimo vuelo hacia el palomar de su casa el p&uacute;blico las recib&iacute;a con un clamor exultante. Luego, se produc&iacute;a un silencio contenido en la nutrida concurrencia hasta que su hijo desanillaba la informaci&oacute;n y le&iacute;a las misivas a la multitud.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111384815.jpg" width="443" height="505" /></p>
<p><em>Santiago Gil (hijo) en el palomar de su padre en la ciudad de Gu&iacute;a.</em></p>
<p>&nbsp;</p>
<p>Las notas no s&oacute;lo se circunscrib&iacute;an a los goles y el resultado final sino incluso a momentos decisivos y an&eacute;cdotas &nbsp;del encuentro.</p>
<p>Como los lectores se pueden imaginar, cuando el partido finalizaba a favor del equipo gu&iacute;ense, las manifestaciones de j&uacute;bilo eran enormes, prolong&aacute;ndose los festejos hasta altas horas de la madrugada.</p>
<p>El equipo del Tirma se fundar&iacute;a el 30 de enero de 1930 y era de reputado prestigio no s&oacute;lo por los campeonatos obtenidos sino por haber tenido en sus filas a jugadores de la clase y celebridad del gran extremo del RC Victoria y Betis Timimi, Pepe Caballero, los hermanos Calero o el gran portero Zacar&iacute;as, &nbsp;jugador del H&eacute;rcules de Alicante que ingresar&iacute;a en el cuadro gu&iacute;ense como entrenador.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111391716_result.jpg" width="417" height="648" /></p>
<p><em>Los guardametas Pepe Calvo y Zacar&iacute;as en los preliminares de un encuentro en el Pepe Gon&ccedil;alves.</em></p>
<p>No cabe duda, que en aquellos tiempos, entre ambos conjuntos hab&iacute;a una enconada rivalidad.</p>
<p>En el referido match, el cuadro galdense se hab&iacute;a adelantado en el marcador por medio de Boro, al incorporarse al ataque en el lanzamiento de un saque de esquina cabeceando el bal&oacute;n al &aacute;ngulo derecho, haciendo in&uacute;til la estirada del guardameta gu&iacute;ense Miguel Armas, al que se le conoc&iacute;a como "El Portero de las "palomitas" por sus c&eacute;lebres estiradas blocando el bal&oacute;n en el aire.</p>
<p>A medida que iba transcurriendo el apasionante encuentro, Boro &nbsp;se afianzaba m&aacute;s y m&aacute;s en el terreno de juego, llegando a desplegar todo un aut&eacute;ntico recital de c&oacute;mo se debe jugar al f&uacute;tbol colectivamente.</p>
<p>Sobresal&iacute;a, igualmente, por su &nbsp;gran dominio del juego a&eacute;reo. Pero, adem&aacute;s, no s&oacute;lo se convertir&iacute;a en una muralla infranqueable cuando el peligro llegaba a sus dominios sino que, desde su demarcaci&oacute;n de medio centro a la antigua se erigir&iacute;a en el organizador de la zona ancha del cuadro galdense y en su m&aacute;s peligroso rematador ante el &aacute;rea rival.</p>
<p>Sin embargo, en las postrimer&iacute;as del encuentro, cuando todos los aficionados esperaban la victoria de su equipo, se produce una pena m&aacute;xima a favor del Tirma muy discutida por el respetable.</p>
<p>El guardameta del conjunto galdense al que apodaban con el sobrenombre de "El Noruego", ten&iacute;a grandes reflejos y colocaci&oacute;n pero se le atribu&iacute;a cierto temor cuando el lanzador contrario pose&iacute;a un fuerte disparo.</p>
<p>Conocedor de esta circunstancia, el entrenador gu&iacute;ense Zacar&iacute;as orden&oacute; lanzar el penalti al ex victorista Pepe Caballero quien ejecutar&iacute;a magistralmente la pena m&aacute;xima de potent&iacute;simo disparo estableciendo &nbsp;el empate final.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111394417-caballero_result.jpg" width="388" height="582" /></p>
<p><em>Pepe Caballero formando en el RC Victoria.</em></p>
<p>La igualdad en la clasificaci&oacute;n entre el Galdense y el Tirma durar&iacute;a toda la competici&oacute;n.</p>
<p>La liga del noroeste estaba integrada por excelentes clubes como el Tirma, Galdense, Moya, San Isidro, Arucas o el Espa&ntilde;ol, un equipo procedente de Agaete.</p>
<p>En la d&eacute;cada de los cincuenta el Tirma pasar&iacute;a a denominarse CD Gu&iacute;a y el Galdense CD G&aacute;ldar.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111404018.jpg" width="524" height="641" /></p>
<p><em>Cromos del CD Tirma que en la d&eacute;cada de los cincuenta pasar&iacute;a a denominarse CD Gu&iacute;a.</em></p>
<p><strong style="font-size: 14px; line-height: 1.4;">Los Hist&oacute;ricos pugnan por su contrataci&oacute;n.</strong></p>
<p><span style="line-height: 1.4;">Tras su militancia en el galdense, el primer club en interesarse por sus servicios fue el laureado RC Victoria, siendo presidente de la entidad albinegra Vicente L&oacute;pez Zocas. El espigado jugador galdense entrenar&iacute;a con la primera plantilla victorista entre la que destacaban C&aacute;stulo, los hermanos Mar&iacute;n, Pacuco Peniche, Pacuco Jorge, Luis Miranda, Alfonso Silva&hellip;</span></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111412619-c--stulo_result.jpg" width="383" height="575" /></p>
<p><em>C&aacute;stulo.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111421120_result.jpg" width="475" height="317" /></p>
<p><em>Los jugadores del RC Victoria Corona, Mat&iacute;as y Pacuco Jorge en el Pepe Gon&ccedil;alves.</em></p>
<p><span style="line-height: 1.4;">Salvador Delgado "Boro", a pesar de vivir sus oto&ntilde;ales d&iacute;as y haber perdido todo contacto con jugadores de aquella &nbsp;&eacute;poca de gran esplendor, revive con nostalgia y suma precisi&oacute;n todos los hechos acontecidos en aquellos a&ntilde;os:</span></p>
<p>"Los entrenamientos del RC Victoria eran habitualmente en el Pepe Gon&ccedil;alves hasta su desaparici&oacute;n. Tambi&eacute;n en un solar colindante al Castillo de la Luz, frente a la sociedad victorista en la calle Juan Rej&oacute;n.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111423221_result.jpg" width="425" height="283" /></p>
<p><em>Estadio Pepe Gon&ccedil;alves.</em></p>
<p>De igual forma, el presidente del Marino, Eufemiano Fuentes, hab&iacute;a enviado varios ojeadores a verme, como el defensa Victoriero o el capit&aacute;n Carmelo Campos quienes me sol&iacute;an recoger en G&aacute;ldar para llevarme a entrenar al campo del Marino, situado en los aleda&ntilde;os de la Plaza de la Feria".</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111425522_result.jpg" width="320" height="448" /></p>
<p><em>Eufemiano Fuentes, presidente del Marino CF</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111431623_result.jpg" width="394" height="591" /></p>
<p><em>Carmelo Campos.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111433824_result.jpg" width="386" height="592" /></p>
<p><em>Luis Molowny defendiendo la el&aacute;tica del Marino antes de producirse su pase al Real Madrid.&nbsp;</em></p>
<p><em>A su lado el valiente defensa Victoriero.</em></p>
<p>Salvador Delgado "Boro" lleg&oacute; a reforzar a ambas plantillas en partidos amistosos, pero la gran calidad de jugadores que atesoraban dichos clubes le hicieron desistir de su intento ya que dicha circunstancia representaba un duro h&aacute;ndicap en su definitiva eclosi&oacute;n futbol&iacute;stica. Por otra parte, la dificultad de compaginar su trabajo en las faenas del mar con el horario de entrenamientos de ambos clubes, muy profesionalizados para la &eacute;poca, requer&iacute;a &iacute;ntegra dedicaci&oacute;n, con el agravante de la lejan&iacute;a y los escasos medios de transporte de aquellos a&ntilde;os:</p>
<p>"En realidad, todo se hubiera podido solventar con esfuerzo y voluntad pero la mayor dificultad estribaba en mi desmesurado apego a mis ra&iacute;ces galdenses.</p>
<p>La simple idea de trasladarme todos los d&iacute;as a la capital afectaba e influ&iacute;a negativamente en mi estado de &aacute;nimo".</p>
<p><strong style="font-size: 14px; line-height: 1.4;">Su fichaje en el Arenas Club.</strong></p>
<p><span style="line-height: 1.4;">A pesar de todo lo expuesto, la vida se nos presenta a veces de forma imprevisible, oblig&aacute;ndonos a cambiar el rumbo de los hechos.</span></p>
<p>Una tarde lluviosa del mes de abril viene a jugar un torneo a G&aacute;ldar, el Arenas Club, con la finalidad de enfrentarse a una selecci&oacute;n del Noroeste. Este equipo, como est&aacute; en la mente de todos, con posterioridad se unir&iacute;a al CD Gran Canaria en la primera fase de la fusi&oacute;n para pasar a denominarse UD Las Palmas.</p>
<p>Como ilustra el peque&ntilde;o formato editado por Bonifacio Hern&aacute;ndez Gil y su empresa Fotograbado Arte, un grupo de muchachos que llevaban la pasi&oacute;n del f&uacute;tbol en la sangre, entre ellos Jacinto S&aacute;nchez y Willy Bird (hermano de Enma Bird, t&iacute;a y madrina del que suscribe esta narraci&oacute;n, de procedencia inglesa), y Anacleto Del Pino fueron entre otros los que gestaron la idea de creaci&oacute;n de un equipo con denominaci&oacute;n brit&aacute;nica: Stranger Club.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111444425-a.jpg" width="369" height="533" /></p>
<p><em>En la imagen portada de la revista Estadio editada en Fotograbado Arte.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111450625-b_result.jpg" width="401" height="598" /></p>
<p>Bonifacio Hern&aacute;ndez Gil.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111452926-fotograbado.jpg" /></p>
<p><em>Fachada principal de Fotograbado Arte en la calle Le&oacute;n y Castillo.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111455227b-bird_result.jpg" width="316" height="474" /></p>
<p><em>Mr. Bird.</em></p>
<p>Transcurrido el tiempo y ya en los albores de la d&eacute;cada de los 30 &ndash;temporada 1932/33- el Stranger Club se constituye de forma oficial, cambiando su nombre por el de Arenas Club, siendo sus organizadores, adem&aacute;s de los ya mencionados, Gregorio Jim&eacute;nez y Vicente Ramos, entre otros.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111462228_result.jpg" width="313" height="470" /></p>
<p><em>Dibujo del escudo del Arenas Club realizado por Alfonso Quiney.</em></p>
<p>Recuperando el hilo narrativo y la trayectoria ascendente de Boro, aquel d&iacute;a en G&aacute;ldar, el espigado jugador norte&ntilde;o tendr&iacute;a una destacada actuaci&oacute;n a pesar del abultado resultado favorable al conjunto del Arenas.</p>
<p>Las circunstancias que hicieron&nbsp; a Boro cambiar de actitud y fichar por un club de la capital nos las expone&nbsp; el propio jugador con suma naturalidad:</p>
<p>"Tras el encuentro, los dirigentes del Arenas acudir&iacute;an a felicitarme, proponi&eacute;ndome ingresar en el club de la calle Ingeniero Salinas, del barrio de Las Alcaravaneras, y aunque el sueldo era de 100 pesetas mensuales, los horarios de entrenamiento eran sustancialmente m&aacute;s flexibles, permiti&eacute;ndome incluso entrenar varios d&iacute;as a la semana en el Campo de Barrial.</p>
<p><strong style="font-size: 14px; line-height: 1.4;">Las promociones con el Arenas Club.</strong></p>
<p><span style="line-height: 1.4;">La eclosi&oacute;n y momento cumbre del Arenas Club tendr&iacute;a lugar en la temporada 1943/44 cuando se proclama campe&oacute;n de 2&ordf; ante el Uni&oacute;n Marina, ascendiendo a 1&ordf; Categor&iacute;a Regional.</span></p>
<p>En puridad, el equipo de Las Alcaravaneras era un cuadro modesto que transitaba entre la Segunda y Primera Categor&iacute;a.</p>
<p>Muy recordada ser&iacute;a la promoci&oacute;n ante el Uni&oacute;n Marina.</p>
<p>Nuestro entrevistado nunca olvidar&aacute; que aquel se&ntilde;alado d&iacute;a, Alfonso Silva le prest&oacute; sus botas para el trascendental encuentro:</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111465929_result.jpg" width="368" height="596" /></p>
<p><em>Alfonso Silva.</em></p>
<p>"Alfonso Silva era una de las personas m&aacute;s generosas que he conocido. Aquellas botas eran de una piel especial que se amoldaban perfectamente al pi&eacute;. No me gustar&iacute;a que se olvidara usted de dejar constancia en este art&iacute;culo de lo que le voy a argumentar, aunque pueda parecer reiterativo.</p>
<p>A lo largo de mi carrera deportiva como jugador en activo e igualmente, con posterioridad, como t&eacute;cnico o simple espectador he podido ver a los jugadores de mayor talento futbol&iacute;stico a nivel nacional, pero le afirmo sin temor&nbsp; a equivocarme que ninguno ha igualado al gran maestro Alfonso Silva. Su forma de jugar era muy diferente al resto, era algo fuera de lo com&uacute;n. A&uacute;n recuerdo cuando vino a nuestra ciudad para jugar dos encuentros en el Pepe Gon&ccedil;alves el Atl&eacute;tico de Aviaci&oacute;n.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111472630_result.jpg" width="459" height="328" /></p>
<p><em>Aspecto que presentaba el campo del Pepe Gon&ccedil;alves momentos antes del encuentro RC Victoria-Atl&eacute;tico de Aviaci&oacute;n.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111482131_result.jpg" width="344" height="501" /></p>
<p><em>Los juagadores del Atl&eacute;tico de Aviaci&oacute;n Mesa y Campos posan para la c&aacute;mara de Hern&aacute;ndez Gil en los preliminares del encuentro.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111492632_result.jpg" width="384" height="601" /></p>
<p><em>Mach&iacute;n.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111495033_result.jpg" /></p>
<p><em>Formaci&oacute;n del Atl&eacute;tico de Aviaci&oacute;n que fue derrotada por el RC Victoria en el estadio Pepe Gon&ccedil;alves en 1944.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111501934_result.jpg" width="390" height="599" /></p>
<p><em>Linea media habitual del RC Victoria formada por Sinforiano, Silva y C&aacute;rdenes.</em></p>
<p>&nbsp;Aquel equipo ven&iacute;a por segunda vez con todas sus grandes figuras, con un centro del campo plagado de internacionales&nbsp; como eran Germ&aacute;n, Gabilondo y Mach&iacute;n. Todos los espectadores y los propios jugadores del Aviaci&oacute;n no daban cr&eacute;dito a lo que estaban viendo, cuando un muchacho a&uacute;n en edad juvenil, les daba una clara demostraci&oacute;n de dominio y maestr&iacute;a. Su estilo al driblar era est&aacute;tico; era sorprendente contemplar c&oacute;mo sin apenas mover el cuerpo, con un simple amago de cintura iba sorteando a todos los adversarios que le sal&iacute;an al paso. Luego, aquella forma y elegancia de desplazar el bal&oacute;n en todas las direcciones, distancias&nbsp; y formas posibles, siempre con aquella elegancia, est&eacute;tica y precisi&oacute;n. En puridad y con el mayor rigor, su f&uacute;tbol era un aut&eacute;ntico espect&aacute;culo en todos los terrenos de juego de la naci&oacute;n. Y la prueba la tiene usted al comprobar c&oacute;mo los estadios se llenaban hasta la bandera para verlo jugar, llegando a convertirse en un verdadero &iacute;dolo de multitudes".</p>
<p><strong style="font-size: 14px; line-height: 1.4;">C&oacute;mo y cu&aacute;ndo naci&oacute; el &iexcl;Arriba d'ellos!</strong></p>
<p><span style="line-height: 1.4;">En la portada del diario Canarias Deportiva con fecha del 16 de julio de 1951, una semana despu&eacute;s del c&eacute;lebre encuentro con el CD M&aacute;laga, apareci&oacute; un art&iacute;culo donde se daba a conocer a los lectores c&oacute;mo hab&iacute;a nacido el grito de guerra del equipo amarillo "arriba de ellos" que sigue vigente en los aficionados en la actualidad.</span></p>
<p>Fue el 5 de julio de 1945, cuando, en una tarde soleada, se jugaba en nuestro estadio una competici&oacute;n que hab&iacute;a despertado un gran inter&eacute;s. Se trataba del partido de promoci&oacute;n entre el Arenas Club, colista de la Primera Regional, y el Racing, que se hab&iacute;a proclamado campe&oacute;n de Segunda. Estos dos clubes hab&iacute;an tenido que llegar a un tercer encuentro disputando el ascenso.</p>
<p>Un p&uacute;blico numeroso llenaba por completo el grader&iacute;o con aplausos a uno y otro equipo. El Racing se adelanta en el marcador y el Arenas empataba poco despu&eacute;s, acabando el partido con igualada a un gol.</p>
<p>Como consecuencia&nbsp; de llegar a la finalizaci&oacute;n del encuentro con ese resultado fue necesario jugar una pr&oacute;rroga. Comenzada &eacute;sta, el Arenas parec&iacute;a que iba a plantear el partido a la defensiva.</p>
<p>De pi&eacute;, agarradas a la barandilla de la grada tres simp&aacute;ticas muchachas comenzaron a lanzar sus gritos de aliento; gritos de entusiasmo, de fe en el triunfo: Arenas, &iexcl;Arriba d&acute;ellos! &iexcl;Arriba d&acute;ellos!.</p>
<p>Como si de algo&nbsp; m&aacute;gico se tratara el Arenas hizo su tanto, el desempate, el tercero y el cuarto&hellip;, y las chicas segu&iacute;an gritando hasta desga&ntilde;itarse: &iexcl;Arriba d&acute;ellos! &iexcl;Arriba d&acute;ellos!</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111504835_result.jpg" width="537" height="354" /></p>
<p><em>Bellas se&ntilde;oritas en las gradas del estadio Pepe Gon&ccedil;alves.</em></p>
<p>Al marcar el Arenas su quinto gol que lo salvaba del descenso a&uacute;n flotaban en todo el estadio las voces femeninas que continuaban gritando&nbsp; enronquecidas: &iexcl;Arriba d&acute;ellos! &iexcl;Arriba d&acute;ellos!</p>
<p>Con este grito de aliento estas bellas muchachas simpatizantes del Arenas Club alentar&iacute;an a los jugadores de Las Alcaravaneras en el emocionante encuentro de promoci&oacute;n.</p>
<p>En este momento de j&uacute;bilo, es de justicia resaltar y recordar a las aut&eacute;nticas creadoras del "&iexcl;Arriba d&acute;ellos!".</p>
<p>Con el transcurso del tiempo este grito de guerra pas&oacute; a formar parte del argot futbol&iacute;stico popular de nuestra isla.</p>
<p>Como el lector puede apreciar el t&eacute;rmino "arriba de ellos" deriv&oacute; en la expresi&oacute;n coloquial&nbsp; "Arriba d&acute; ellos" produci&eacute;ndose una elipsis fon&eacute;tica por p&eacute;rdida de vocal.</p>
<p><strong style="font-size: 14px; line-height: 1.4;">La generosidad de la madrina del Marino, D&ordf;. Adela Naun, suegra del inolvidable capit&aacute;n del pa&ntilde;uelo Juanito Beltr&aacute;n.</strong></p>
<p><span style="line-height: 1.4;">Otro momento inolvidable que ha quedado grabado en la vida deportiva de Boro fue la espectacular e inesperada victoria del Arenas sobre el Marino, un equipo campe&oacute;n repleto de figuras:</span></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111511436_result.jpg" width="493" height="332" /></p>
<p><em>Salvador Delgado Su&aacute;res (Boro) ejerciendo como capit&aacute;n del Arenas Club &nbsp;ante el Marino CF.</em></p>
<p>"Aquel encuentro fue jugado de forma sensacional por nuestra parte y a pesar de las grandes individualidades del once marinista sus jugadores no pudieron reaccionar en todo el encuentro ante la inspiraci&oacute;n de nuestro equipo.</p>
<p>A medida que iba transcurriendo el encuentro se iba acrecentando el nerviosismo en sus filas y por el contrario la moral de nuestros jugadores iba en gradaci&oacute;n ascendente.</p>
<p>Al final de la contienda D&ordf;. Adela Naun, suegra de Juanito Beltr&aacute;n, madrina del Marino y toda una instituci&oacute;n en el club de Fuera de la Portada nos ofreci&oacute; un gran agasajo en su propio domicilio de Leopoldo Matos &ndash;ya desaparecido por el T&uacute;nel de Luengo - frente a la sociedad del CD Gran Canaria en la Plazoleta de Luis Ant&uacute;nez n&uacute;mero uno que, tras la primera fase de la fusi&oacute;n&nbsp; pasar&iacute;a a convertirse en la primera sede social del club amarillo , siendo donada con todos sus trofeos y pertenencias.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111513837_result.jpg" /></p>
<p><em>Los componentes del Marino CF posando para la c&aacute;mara en compa&ntilde;&iacute;oa de su madrina D&ordf; Adela Naun tras obtener el campeonato regional.</em></p>
<p>Esta mujer era digna de toda alabanza. Recuerdo que tras la fundaci&oacute;n de la UD Las Palmas, en los grandes encuentros de nuestro equipo, se presentaba en la sede con el almuerzo de todos los empleados y siempre estaba pendiente del m&aacute;s m&iacute;nimo detalle que pudiera amenazar el desarrollo normal de la entidad.</p>
<p><strong style="font-size: 14px; line-height: 1.4;">Listero en una empresa de carb&oacute;n.</strong></p>
<p><span style="line-height: 1.4;">Tampoco nuestro entrevistado quiere dejar de mencionar su fugaz paso por una empresa de carb&oacute;n:</span></p>
<p>"Percat&aacute;ndome del gran esfuerzo f&iacute;sico que me ve&iacute;a obligado a realizar diariamente, los directivos del Arenas me buscaron un empleo como listero en una empresa de carb&oacute;n inglesa en el Puerto de la Luz. Las condiciones de trabajo y el trato eran magn&iacute;ficas pero como ya le he mentado con anterioridad en otros cap&iacute;tulos de mi vida deportiva y laboral, me costaba mucho permanecer tantas horas fuera de mi entorno. La ciudad de Las Palmas me agobiaba e intranquilizaba. Es curioso, pero a pesar de tantos a&ntilde;os transcurridos, a&uacute;n sigue despertando en mi persona el mismo estado an&iacute;mico.</p>
<p>Trat&eacute; de aguantar lo indecible pero un buen d&iacute;a, sin motivo aparente ni comunic&aacute;rselo a nadie, cog&iacute; todos mis b&aacute;rtulos y me vine de nuevo a respirar aire puro en mi barrio natal de La Monta&ntilde;a.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111521538.jpg" width="508" height="391" /></p>
<p><em>Paisaje costumbrista de G&aacute;ldar en la d&eacute;cada de los cuarenta.</em></p>
<p>S&eacute; que no obr&eacute; bien con mis superiores y compa&ntilde;eros, y ped&iacute; perd&oacute;n por ello, pero no lo pude evitar".</p>
<p><strong style="font-size: 14px; line-height: 1.4;">Del Pepe Gon&ccedil;alves al solar conocido como La Loma.</strong></p>
<p><span style="line-height: 1.4;">A tenor de mis investigaciones, reportajes cinematogr&aacute;ficos o instant&aacute;neas gr&aacute;ficas, es de suponer que en aquellos a&ntilde;os de la d&eacute;cada de los 30 y 40, en la ciudad de Las Palmas, hab&iacute;a muchos solares y campos no acotados donde poder entrenar asiduamente aparte de los de su ciudad natal.</span></p>
<p>"En realidad, aunque jugaba en el Arenas, yo llegar&iacute;a a entrenar en todos los campos y equipos.</p>
<p>En un principio, cuando jug&aacute;bamos en el Pepe Gon&ccedil;alves, el Estadio Insular era todav&iacute;a un solar al que llamaban el Campo de La Loma ya que con ese nombre denominaban a esa zona de la parte alta de la ciudad, donde ven&iacute;an a morir las dunas de arena en el que ser&iacute;a luego Paseo de Chil. Recuerdo que hab&iacute;a cuatro casas en lo alto de la loma que frenaban algo la intensidad de los grandes vendavales de arena que corr&iacute;an dunas abajo en direcci&oacute;n a la futura Grada Curva, donde hab&iacute;a un aljibe de agua, llegando hasta las primeras casas construidas en Ciudad Jard&iacute;n. En ese terreno de arena no acotado ya se jugaba al f&uacute;tbol desde &eacute;pocas pret&eacute;ritas. Luego, vendr&iacute;a la compra del solar por la empresa Marino CF y con posterioridad la denominaci&oacute;n de Estadio Las Palmas.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1111524139-ok_result.jpg" width="468" height="312" /></p>
<p><em>Panor&aacute;mica de las arenas de La Loma antes de ser constru&iacute;da la Grada Curva.</em></p>
<p>Tambi&eacute;n hab&iacute;a otros campos donde se formaban los equipos de barrios no federados: Campo del Palo, Las Brujas, o frente al propio Estadio Las Palmas, donde hab&iacute;a un campo de grandes dimensiones, hoy construido de calles y casas. Tambi&eacute;n en la propia playa de Las Alcaravaneras donde se celebraban espectaculares campeonatos con una nutrida presencia de p&uacute;blico.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113313440_result.jpg" width="576" height="375" /></p>
<p><em>Imagen de la Playa de las Alcaravaneras en la d&eacute;cada de los cuarenta, donde ten&iacute;an lugar apasionantes campeonatos playeros.</em></p>
<p>En La Isleta hab&iacute;a campos del ej&eacute;rcito y con posterioridad La Piscina del Jard&iacute;n de la Infancia.</p>
<p>El Ej&eacute;rcito del Aire ten&iacute;a su propio terreno donde jugaba el Aviaci&oacute;n. En Las Palmas. El Campo del Cementerio, Barranco del Guiniguada, Estanque de San Jos&eacute;, Casa del Ni&ntilde;o (hasta construirse la Ciudad Deportiva Mart&iacute;n Freire en el ecuador de la d&eacute;cada de los 50).</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113315741_result.jpg" width="569" height="380" /></p>
<p><em>Partido de j&oacute;venes canteranos en &nbsp;el campo de La Casa del Ni&ntilde;o. Antes de construirse la Ciudad Deportiva Mart&iacute;n Freire.</em></p>
<p>En la Zona Alta hab&iacute;a tambi&eacute;n muchos terrenos de juego: El Polvor&iacute;n de la &eacute;poca de los hist&oacute;ricos, Estanque de La Paterna, Schamann, el campo del Chile, el Antonio Rojas&hellip;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113322542.jpg" width="567" height="411" /></p>
<p><em>Campos del Polvor&iacute;n en la zona alta de la ciudad.</em></p>
<p>En mi &eacute;poca del Arenas, en un principio, por mi situaci&oacute;n particular y la lejan&iacute;a con G&aacute;ldar, bajaba a entrenar a la capital una vez a la semana, ejercit&aacute;ndome el resto de los d&iacute;as en el Estadio de Barrial. Una vez construido el Estadio Las Palmas, dejamos de practicar en el Pepe Gon&ccedil;alves y entren&aacute;bamos normalmente en el recinto de Ciudad Jard&iacute;n, compartiendo los d&iacute;as con el CD Gran Canaria y naturalmente el Marino CF que era el verdadero propietario del terreno.</p>
<p>El equipo blanquiazul tambi&eacute;n sol&iacute;a realizar sus entrenamientos en el viejo campo del Marino, en los aleda&ntilde;os de la Plaza de la Feria.</p>
<p>El Atl&eacute;tico Club entrenaba normalmente en el Campo de Fuentes, cerca de la Iglesia del Pino, denominado con este nombre al estar situado el terreno cerca de la f&aacute;brica de ladrillos de D. Eufemiano Fuentes. Era un terreno arenoso donde jugaban los equipos regionales y juveniles.</p>
<p>En Guanarteme, en los alrededores de la f&aacute;brica de&nbsp; Lloret y Llinares hab&iacute;a otro campo situado en el mismo barranco. Igualmente el terreno de La C&iacute;cer que era un aut&eacute;ntico vivero de jugadores. Muchos confunden el campo de La C&iacute;cer con un lugar de la Playa de Las Canteras llamado con el mismo nombre donde igualmente se practicaba el f&uacute;tbol playero.</p>
<p>De all&iacute; saldr&iacute;an grandes jugadores como Manolo Montes, Rafael Mujiica, Manol&iacute;n, Tatono, Mac&iacute;as&hellip;</p>
<p>El RC Victoria, por proximidad geogr&aacute;fica prefer&iacute;a el Pepe Gon&ccedil;alves, que hab&iacute;a sido construido por la Junta de Obras del Puerto, aunque en ocasiones se decantaba por un solar colindante con el Castillo de la Luz, que estaba situado frente a la antigua sede del RC Victoria en la calle Juan Rej&oacute;n.</p>
<p>Con posterioridad, ya en los &uacute;ltimos a&ntilde;os de la d&eacute;cada de los 40, todos los equipos compart&iacute;an el Estadio Las Palmas, fijando sus propios horarios".</p>
<p><strong style="font-size: 14px; line-height: 1.4;">Un medio centro de altura.</strong></p>
<p><span style="line-height: 1.4;">Salvador Delgado Su&aacute;rez (Boro) aportar&iacute;a al Arenas Club solidez, contundencia defensiva y un gran despliegue f&iacute;sico en la demarcaci&oacute;n de medio centro, cuajando cinco espl&eacute;ndidas temporadas en el equipo de la camisola roja.</span></p>
<p>Debido a su discreci&oacute;n y modestia le cuesta definirse como jugador o hacer una valoraci&oacute;n de su meritoria trayectoria deportiva:</p>
<p>"Nunca me ha gustado hablar sobre mi persona y es por ello que son contadas las entrevistas que me han hecho a lo largo de mi vida. A todos nos gustan los halagos. Sin embargo, yo sab&iacute;a mejor que nadie c&oacute;mo hab&iacute;a sido mi actuaci&oacute;n y si hab&iacute;a rayado a gran altura o de forma deficiente.</p>
<p>Por regla general aceptaba las cr&iacute;ticas adversas, que afortunadamente fueron pocas, pero hab&iacute;a jugadores a los que se trataba injustamente, como fue el caso de Alfonso Silva en la capital de Espa&ntilde;a.</p>
<p>En mis primeros a&ntilde;os, tanto en el Galdense como en el Arenas Club, era natural que debido a mi gran corpulencia f&iacute;sica cubriera mucho campo y el esfuerzo que a otros jugadores les costaba llegar al &aacute;rea rival y replegarse, a m&iacute; me resultaba menos dificultoso. Igualmente, dada mi gran estatura, ten&iacute;a gran facilidad en el juego a&eacute;reo, tanto cortando los avances y centros de los equipos rivales como cuando me incorporaba al ataque en las faltas o saques de esquina, donde llegu&eacute; a marcar un considerable n&uacute;mero de goles, algunos decisivos para mi equipo.</p>
<p>En la UD Las Palmas no tuve oportunidad de demostrarlo por mi inesperada lesi&oacute;n y la demarcaci&oacute;n que sol&iacute;a ocupar en el terreno de juego.</p>
<p>Aunque el club me pagaba el transporte a la ciudad, las necesidades en casa eran imperiosas. Sol&iacute;a ponerme de acuerdo con los trabajadores de las fincas de plataneras y ganaderos que bajaban en camiones diariamente a la capital. Cuando no hab&iacute;a posibilidad tomaba los populares Coches de Hora o de Meli&aacute;n de la zona norte.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113325243_result.jpg" width="517" height="350" /></p>
<p><em>En la imagen un t&iacute;pico cami&oacute;n donde se transportaban animales y lecheras en su camino hacia la ciudad de Las Palmas.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113331944_result.jpg" width="465" height="303" /></p>
<p><em>Coche de hora de la compa&ntilde;&iacute;a Meli&aacute;n &amp; CIA en su camino hacia la estaci&oacute;n de Bravo Murillo.</em></p>
<p>Se daba la circunstancia que el director administrativo de la compa&ntilde;&iacute;a Meli&aacute;n &amp; CIA. era Luis Gonz&aacute;lez Vera que en aquellos a&ntilde;os llegar&iacute;a a ser presidente del Arenas Club y con posterioridad miembro de La Ponencia de Fusi&oacute;n que cre&oacute; la UD Las Palmas, y su primer director general.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113333845-a_result.jpg" width="345" height="514" /></p>
<p><em>Luis Gonz&aacute;lez Vera.</em></p>
<p>Eran viajes muy largos, par&aacute;ndonos en cada kil&oacute;metro y donde el estado de los transportes frecuentemente sufr&iacute;an aver&iacute;as a lo largo del trayecto. En el Coche de Hora pod&iacute;an ir toda clase de utensilios, animales y lecheras, que iban dejando en sus sitios de destino".</p>
<p><span style="line-height: 1.4;">Nuestro bravo y pundonoroso medio centro tambi&eacute;n alberga muchos recuerdos de la sede social de Las Alcaravaneras, muy cerca del CD Gran Canaria, en la Plazoleta Luis Ant&uacute;nez, n&ordm; 1. La &uacute;nica diferencia estriba en que la sede del equipo blanco fue la &uacute;nica que don&oacute; al nuevo club todos sus trofeos y pertenencias, pasando a ser habitada por sus nuevos inquilinos: La UD Las Palmas.</span></p>
<p>El resto de sedes sociales siguieron funcionando como clubes recreativos. "&iquest;C&oacute;mo podr&iacute;a olvidarme de aquella sede social? Forma parte de una juventud que ya no ha de volver. Fueron muchas horas de convivencia con compa&ntilde;eros, donde reinaba una gran camarader&iacute;a. En tardes triunfales la llegada a la sede social era una aut&eacute;ntica fiesta. Los socios y aficionados del Barrio de Las Alcaravaneras ya nos estaban esperando y el ambiente que reinaba dentro de ella era indescriptible. La fiesta se pod&iacute;a prolongar hasta altas horas de la madrugada.</p>
<p>En d&iacute;as amargos, el sinsabor se reflejaba en los rostros graves y circunspectos de los socios y el silencio sepulcral del entorno. Hay que considerar que el Arenas era un club modesto, administrado a base de grandes penurias econ&oacute;micas. S&oacute;lo el hecho de terminar por consolidarnos en Primera Categor&iacute;a Regional junto a los hist&oacute;ricos era ya un inmenso triunfo".</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113340645-b_result.jpg" width="495" height="334" /></p>
<p><em>Equipo del Arenas Club posando para la c&aacute;mara en el Estadio Las Palmas en la d&eacute;cada de los cuarenta.</em></p>
<p>En d&iacute;as laborales la sociedad era muy transitada y concurrida. Se organizaban torneos de domin&oacute;, ajedrez y juegos de cartas. Los domingos y d&iacute;as festivos se celebraban espectaculares bailes con orquestas que ten&iacute;an gran aceptaci&oacute;n entre los j&oacute;venes de aquel sector de la ciudad.</p>
<p>Tenemos que considerar que en aquellos a&ntilde;os no hab&iacute;an las facilidades y lugares de diversi&oacute;n que pueden existir en la actualidad y las clases modestas ten&iacute;an menos recursos; hab&iacute;a grandes diferencias sociales.</p>
<p>La sede ten&iacute;a tambi&eacute;n&nbsp; un gran olor a salitre y arena&nbsp; ya que el trasiego de veleros y botes que pernoctaban en ella era continuo.</p>
<p>En la parte alta de la sociedad se hallaba una amplia terraza con inmejorables vistas de la bah&iacute;a. En ese hermoso lugar hab&iacute;a instalado un gimnasio de boxeo donde se ejercitaban diariamente grandes p&uacute;giles de la &eacute;poca.</p>
<p>Recuerdo las lecciones en la pizarra de t&eacute;cnica, t&aacute;ctica y estrategia impartidas por el entrenador Miguelito Toledo en el primer piso de la sede. Nosotros contempl&aacute;bamos a trav&eacute;s del tragaluz las sesiones de guantes, guanteletas, punching ball, saco, sombra&hellip; Cada asalto ten&iacute;a una duraci&oacute;n de tres minutos; los &uacute;ltimos segundos iban acompa&ntilde;ados del grito &iexcl;Quince&hellip;!, donde los p&uacute;giles doblaban su intensidad hasta escuchar el reparador &iexcl;Fuera!</p>
<p>Todo aquel entramado de sonidos formaba un ambiente agradable y acogedor.</p>
<p>Hab&iacute;a una gran familiaridad y todos los deportistas de diferentes especialidades ten&iacute;amos un trato muy cercano".</p>
<p><strong style="font-size: 14px; line-height: 1.4;">Teodoro Guerra, malograda figura del balompi&eacute; canario.</strong></p>
<p><span style="line-height: 1.4;">Salvador Delgado (Boro) y Teodoro Guerra tuvieron vidas muy paralelas cuando ambos integraban el Galdense como cuando formaban parte del Arenas Club. Teodoro Guerra era considerado una de las m&aacute;s firmes promesas del balompi&eacute; canario pero su vida deportiva quedar&iacute;a truncada por un inesperado golpe del destino&hellip; "Teodoro siempre permanecer&aacute; en mi memoria. Se trataba de un aut&eacute;ntico fuera de serie que, de no fallecer en plena juventud, estaba llamado a convertirse en una figura a nivel nacional. Su prematura muerte nos conmocion&oacute; a todos. De extracci&oacute;n rural y modesta, trabajaba de panadero durante la noche. En aquellos a&ntilde;os de postguerra los medios y condiciones laborales no eran los de hoy y con respecto a sanidad exist&iacute;an muchas carencias que originaban un alto &iacute;ndice de fallecimientos. Personas de escasos recursos mor&iacute;an con frecuencia de enfermedades que en la actualidad tendr&iacute;an f&aacute;cil soluci&oacute;n.</span></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113343146_result.jpg" width="400" height="569" /></p>
<p><em>Los jugadores del Arenas Club Pepene, Boro y Teodoro en el Estadio Las Palmas antes de un encuentro con el CD Gran Canaria.</em></p>
<p>Teodoro enferm&oacute; con los duros contrastes de temperatura, al compaginar la le&ntilde;a de los fogones de la panader&iacute;a, con aquel calor abrasador durante las largas y lentas noches y el intenso fr&iacute;o al salir de su lugar de trabajo, a&uacute;n sin dar los claros del alba, a repartir el m&aacute;s preciado alimento por todos los pueblos del municipio galdense.</p>
<p>Era, sin lugar a dudas, nuestro mejor jugador y todos los grandes equipos comenzaban a disputarse su fichaje, pero su salud fue quebrando paulatinamente hasta apagarse para siempre en el momento de mayor esplendor futbol&iacute;stico.</p>
<p>El Arenas Club sinti&oacute; mucho su p&eacute;rdida y las manifestaciones de dolor en toda la ciudad, al igual que con posterioridad ocurri&oacute; con Antonio Vieira, ser&iacute;an multitudinarias.</p>
<p><strong style="font-size: 14px; line-height: 1.4;">Primera fase de la fusi&oacute;n y el brillante marcaje de Yayo a Polo.</strong></p>
<p><span style="line-height: 1.4;">Algunos compa&ntilde;eros&nbsp; que compartieron momentos estelares con Boro en el Arenas Club fueron ingresando gradualmente en el reci&eacute;n nacido equipo &uacute;nico procedentes de los clubes hist&oacute;ricos.</span></p>
<p>Como muchos de nuestros lectores conocer&aacute;n, el Arenas Club se unir&iacute;a al CD Gran Canaria en la primera fase de la fusi&oacute;n para pasar a denominarse UD Las Palmas.</p>
<p>"Todos fuimos llegando casi a un mismo tiempo tras jugar la Liga Provincial Extra Oficial.</p>
<p>Eladio Bueno Ramos (Yayo) hab&iacute;a sido un excelente compa&ntilde;ero en el Arenas Club que me dej&oacute; profunda huella por su extrema generosidad y rectitud. Se desviv&iacute;a por los problemas sociales ajenos y era un ser humano excepcional. He sentido mucho su reciente fallecimiento.</p>
<p>Sin embargo, el a&ntilde;o 1949, cuando tuvo lugar la fusi&oacute;n de los clubes, &eacute;l ya hac&iacute;a varios a&ntilde;os que hab&iacute;a sido traspasado al RC Victoria, fruto de sus notables actuaciones en el Arenas. Integr&oacute; una retaguardia cl&aacute;sica en el club victorista que se har&iacute;a muy popular: Montes, Casta&ntilde;ares y Yayo. Hay que entender que todav&iacute;a en aquellos tiempos se jugaba con dos defensas.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113345847_result.jpg" width="421" height="284" /></p>
<p><em>L&iacute;nea defensiva del RC Victoria, antes de la implantaci&oacute;n de la WM, formada por el guardameta Manolo Montes y los defensas Casta&ntilde;ares y Yayo.</em></p>
<p>A las &oacute;rdenes del t&eacute;cnico y odont&oacute;logo de profesi&oacute;n, D. Jes&uacute;s Navarro, crearon un equipo muy potente, obteniendo el t&iacute;tulo de Campe&oacute;n de Campeones. Ten&iacute;an una plantilla realmente envidiable: Montes, Casta&ntilde;ares, Yayo, Ignacio, Vieira, Yoyo De la Torre, Tacoronte, Alberto, Manol&iacute;n, Pe&ntilde;a, Miguel El Palmero&hellip;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113353648_result.jpg" width="459" height="299" /></p>
<p><em>El RC Victoria en el campo de La Manzanilla en la ciudad de La Laguna.</em></p>
<p>Del Arenas Club, los primeros en aterrizar al equipo amarillo fuimos Miguel Toledo (defensa izquierdo) y un servidor (medio centro). Por el CD Gran Canaria, que a&ntilde;os antes se hab&iacute;a denominado Gimn&aacute;stica Gran Canaria, el primero en llegar fue Juan Mac&iacute;as, seguido de Anto&ntilde;ito Jorge.</p>
<p>En los comienzos se jugaron partidos amistosos para ir configurando el equipo base.</p>
<p>En un encuentro entre la UD Las Palmas y el RC Victoria, Jes&uacute;s Navarro, que dirig&iacute;a por aquellos a&ntilde;os al equipo albinegro, gritaba desde la banda de muy mal humor al comprobar que el jugador amarillo Polo &ndash;primer capit&aacute;n de la UD Las Palmas- no s&oacute;lo se erig&iacute;a en due&ntilde;o y se&ntilde;or del centro del campo, sino que se convirti&oacute; en el m&aacute;ximo realizador de su equipo marcando dos goles.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113363149_result.jpg" width="353" height="530" /></p>
<p><em>Eladio Bueno Ramos (Yayo) formando en las filas del RC Victoria.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113365850_result.jpg" width="361" height="518" /></p>
<p><em>Sebasti&aacute;n Rodr&iacute;guez Mendoza (Polo).</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113373651_result.jpg" width="357" height="370" /></p>
<p><em>Jes&uacute;s Navarro, entrenador por aquel entonces del RC Victoria.</em></p>
<p>Tras la primera mitad, el Sr. Navarro orden&oacute; a Yayo el marcaje de Polo. La consigna era seguirle f&eacute;rreamente por todo el terreno de juego, saliendo airoso de su cometido. En realidad, el lateral izquierdo victorista le har&iacute;a un marcaje impecable, no dej&aacute;ndole tocar bal&oacute;n. El resultado que era desfavorable en el descanso para los victoristas, tras los dos soberbios goles de Polo, dar&iacute;a un giro espectacular en la segunda mitad terminando venciendo el RC Victoria por tres tantos a dos. Desde aquel d&iacute;a Yayo se integrar&iacute;a al equipo amarillo desplazando de la titularidad a Miguel Toledo y otros jugadores que hab&iacute;an venido ocupando la plaza de lateral izquierdo, como Pantale&oacute;n o el defensa ambidiestro procedente del Atl&eacute;tico Club, Viera.</p>
<p>Tras aquellos partidos amistosos se consolidar&iacute;a la popular retaguardia formada por Montes, Casta&ntilde;ares, Juanono y Yayo, defensa inexpugnable y una de las m&aacute;s mencionadas y laureadas del f&uacute;tbol canario de todos los tiempos, por la gran cantidad de&nbsp; encuentros que formaron en la alineaci&oacute;n titular".</p>
<p><strong style="font-size: 14px; line-height: 1.4;">Salvador Delgado Su&aacute;rez (Boro) ficha en la UD Las Palmas.</strong></p>
<p><span style="line-height: 1.4;">Nada hac&iacute;a presagiar al joven Boro cuando jugaba en el terreno de Los Albercoles o el de Barrial de la por aquel entonces rec&oacute;ndita zona del noroeste, que un d&iacute;a se&ntilde;alado -4 de febrero de 1949- el vicepresidente de la Federaci&oacute;n Regional de Las Palmas, D. Manuel Rodr&iacute;guez Monroy, presentar&iacute;a una moci&oacute;n en dicha entidad federativa con la finalidad de configurar un equipo &uacute;nico, tras la renuncia a todo un pasado hist&oacute;rico a trav&eacute;s de un proyecto de fusi&oacute;n. Mucho menos que &eacute;l podr&iacute;a llegar a formar parte de aquel equipo que nos representar&iacute;a a nivel nacional.</span></p>
<p>"Todo aquello nos cogi&oacute; en un principio de sorpresa. Una vez constituida la UD Las Palmas en la Asamblea Magna del RC N&aacute;utico y siendo precisamente el Arenas uno de los equipos de la primer fase de la fusi&oacute;n, es natural que comenzaran a llegarme comentarios sobre la posibilidad de mi fichaje por el club reci&eacute;n creado ya que dicho con la mayor modestia, era considerado uno de los jugadores m&aacute;s destacados de mi equipo.</p>
<p>La primera persona en comunic&aacute;rmelo directamente fue D. Luis Gonz&aacute;lez Vera, que hab&iacute;a sido presidente del Arenas Club en los &uacute;ltimos a&ntilde;os. D. Luis era una persona encantadora, hab&iacute;a formado parte de la Ponencia de Fusi&oacute;n que fundar&iacute;a la UD Las Palmas. En la primera etapa del club amarillo integr&oacute; la primera gestora del club presidida por D. Jos&eacute; Del R&iacute;o Amor, a la vez que fue el primer Director General del club amarillo.</p>
<p>Tambi&eacute;n fueron claves en aquella gesti&oacute;n D. Jos&eacute; S&aacute;nchez S&aacute;nchez, que hac&iacute;a las labores de Delegado de Enlace y al que todos conoc&iacute;amos por el sobrenombre de "Pepito Pellagofio" por su oronda fisonom&iacute;a. Era un hombre de campo &ndash;proced&iacute;a de San Mateo- de car&aacute;cter bonach&oacute;n, que se desviv&iacute;a por los jugadores y al que todos quer&iacute;amos mucho.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113290952_result.jpg" width="383" height="557" /></p>
<p><em>En la imagen, de izquierda a derecha: Jos&eacute; S&aacute;nchez S&aacute;nchez, Carmelo Campos e Hilario Marrero.</em></p>
<p>Este apelativo tan popular de "Pellagofio" no implicaba falta de respeto o mofa hacia su persona sino que proven&iacute;a del exceso de familiaridad, amistad y cari&ntilde;o que todos sent&iacute;amos hacia su persona. Para todos los jugadores fundacionales fue el directivo m&aacute;s cercano, querido y apreciado.</p>
<p>Un buen d&iacute;a, D. Jos&eacute; me llevar&iacute;a a la ferreter&iacute;a "El Candado", situada en la calle Triana, esquina San Pedro. En aquella tienda-almac&eacute;n, tan particular, rodeado de utensilios de labranza, clavos e instrumentos de cuerda, me esperaba el directivo Expedito Calder&iacute;n, donde comenzar&iacute;an a iniciarse las negociaciones. Con posterioridad, me trasladar&iacute;a a la antigua sede social del CD Gran Canaria donde se formalizar&iacute;a el definitivo contrato".</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113283753.jpg" width="275" height="379" /></p>
<p><em>Expedito Calder&iacute;n.</em></p>
<p>A la pregunta de si se hab&iacute;an dilatado en exceso las negociaciones, Boro r&iacute;e abiertamente:</p>
<p>"En mis tiempos, el simple hecho de llegar a defender los colores de la UD Las Palmas representaba todo un honor; ten&iacute;a tambi&eacute;n un sentido patri&oacute;tico dif&iacute;cil de explicar con palabras.</p>
<p>Era un club reci&eacute;n creado, un signo de identidad que comenzaba por primera vez en la historia a difundirse a nivel nacional. &Eacute;ramos el epicentro de todas las noticias y considerados una especie de h&eacute;roes o elegidos de la fortuna por la ciudadan&iacute;a.</p>
<p>Para una familia tan modesta como era la m&iacute;a, aquellas cantidades, aunque en la actualidad puedan parecer irrisorias, ven&iacute;an a mitigar un gran n&uacute;mero de necesidades en nuestros hogares".</p>
<p>Salvador Delgado (Boro) firm&oacute; por una cantidad mensual de 500 pesetas.</p>
<p>En el concepto de primas por partidos ganados en campo contrario 50 pesetas, mientras que en campo propio la mitad.</p>
<p>El compromiso del jugador del Arenas con la entidad amarilla era por tres temporadas. El club se compromet&iacute;a a abonar al jugador por prima de fichaje la cantidad de 3.000 pesetas al comenzar cada temporada y una cantidad igual si ascend&iacute;an a la Segunda Divisi&oacute;n Nacional, siempre que permaneciera en activo en dicha entidad.</p>
<p>A partir del comienzo de la temporada siguiente de la fecha del ascenso la mensualidad se incrementar&iacute;a a 1.000 pesetas, percibiendo adem&aacute;s 50 pesetas como incentivo cada vez que fuese alineado en el equipo.</p>
<p>La firma del contrato tuvo lugar en la antigua sala de juntas de Luis Ant&uacute;nez, actuando como testigo el directivo y tesorero D. Jos&eacute; Jim&eacute;nez S&aacute;nchez y como secretario D. Luis Rivero Noble, ambos antiguos miembros del CD Gran Canaria.</p>
<p>En el contrato qued&oacute; registrada la fecha del 30 de septiembre de 1949.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113280954_result.jpg" width="539" height="424" /></p>
<p><em>Licencia federativa del jugador Salvador Delgado Su&aacute;rez (Boro).</em></p>
<p>&nbsp;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113271755_result.jpg" width="526" height="737" /></p>
<p>&nbsp;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113265056_result.jpg" width="525" height="736" /></p>
<p>Realci&oacute;n contractual del jugador Salvador Delgado Su&aacute;rez (Boro) con la UD Las Palmas.</p>
<p><span style="font-size: 14px;"><strong>T&eacute;cnicos y mentores en su carrera deportiva.</strong></span></p>
<p><span style="line-height: 1.4;">En el cap&iacute;tulo de entrenadores que ocupar&iacute;an un lugar significativo en su vida deportiva, Boro se muestra reacio a otorgar un lugar relevante a alguno de ellos, haci&eacute;ndonos saber las dificultades que entra&ntilde;a este cargo:</span></p>
<p>"Siempre tendr&eacute; una deuda de gratitud con el Sr. Molinos, ya que fue mi primer mentor y quien me dio la oportunidad de orientar mi vida hacia este deporte. Su aprendizaje futbol&iacute;stico podr&aacute; parecernos rudimentario si tenemos en cuenta la evoluci&oacute;n que muy pronto fue adquiriendo el mundo del balompi&eacute; tras la WM.</p>
<p>De &eacute;l aprend&iacute;, no obstante, c&oacute;mo deb&iacute;a ubicarme en el terreno de juego y quien mejor supo explotar mis condiciones f&iacute;sicas y la capacidad de sacrificio en el juego colectivo.</p>
<p>En el Arenas Club el salto cualitativo era sustancial pero tambi&eacute;n es verdad que la calidad de los compa&ntilde;eros era superior y nos repart&iacute;amos el trabajo. El entrenador era Miguelito Toledo. Su gran logro fue dar con mi exacta demarcaci&oacute;n como medio centro y darme libertad para subir y rematar, convirti&eacute;ndome en uno de los mayores realizadores del equipo.</p>
<p>Tras mi ingreso en la UD Las Palmas todo fue muy diferente. Dada mi corta estancia en el club, s&oacute;lo tuve dos entrenadores. El primero fue Pancho Arencibia, nacido en Cuba, aunque tinerfe&ntilde;o de adopci&oacute;n, al que apodaban "El Divino Calvo" y llegaba con un amplio historial a sus espaldas al haber integrado el mejor CD Tenerife de la historia, campe&oacute;n con el Atl&eacute;tico de Aviaci&oacute;n, internacional absoluto&hellip;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113253057.jpg" width="299" height="449" /></p>
<p><em>Francisco Mart&iacute;n Arencibia (Pancho Arencibia), primer entrenador de la UD Las Palmas.</em></p>
<p>Cuando se retir&oacute; del f&uacute;tbol activo pas&oacute; a ocupar un cargo de funcionario en AENA en el antiguo aeropuerto de Gando.</p>
<p>Ante la imposibilidad de fichar a Luis Valle, erradicado en Madrid por motivos profesionales tras una larga estancia como exiliado, los rectores del club deciden contratar los servicios del ex jugador rojiblanco.</p>
<p>Era un entrenador de grandes conocimientos t&eacute;cnicos y sab&iacute;a c&oacute;mo tratar al jugador en cada momento. Sin embargo, nunca pude mostrar el f&uacute;tbol que llevaba dentro. Mi demarcaci&oacute;n la ocupaba Sebasti&aacute;n Rodr&iacute;guez Mendoza (Polo) que fue el primer capit&aacute;n de la UD Las Palmas y ten&iacute;a gran familiaridad con el t&eacute;cnico, ya que ambos hab&iacute;an coincidido en el Atl&eacute;tico Aviaci&oacute;n como jugadores.</p>
<p>A&uacute;n desconozco las razones de su dimisi&oacute;n cuando s&oacute;lo contaba con varios meses en el cargo.</p>
<p>Francisco Arencibia era todo un caballero, neg&aacute;ndose a percibir las cantidades que el club le adeudaba. Fue sustituido por Nicol&aacute;s Martin&oacute;n, m&eacute;dico militar al que conoc&iacute;a de su &eacute;poca como seleccionador regional.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113250558-martinon_result.jpg" width="354" height="531" /></p>
<p><em>Nicol&aacute;s Martin&oacute;n, m&eacute;dico militar de profesi&oacute;n y segundo entrenador del club.</em></p>
<p>Persona de fuerte car&aacute;cter, no toleraba la indisciplina ni las injerencias de los directivos en su labor. Entiendo que realiz&oacute; un magn&iacute;fico trabajo en el club hasta la llegada de Jes&uacute;s Navarro Mazotti.</p>
<p>Antes de su incorporaci&oacute;n, tras la dimisi&oacute;n de Nicol&aacute;s Martin&oacute;n, el directivo D. Juan Trujillo Febles asume las funciones de entrenador, actuando como auxiliar el Director General D. Luis Gonz&aacute;lez Vera, algo impensable en nuestros d&iacute;as. De todas formas fue s&oacute;lo en un encuentro ante el Marino -5 de marzo de 1950- que termin&oacute; con empate a dos tantos.</p>
<p>El verdadero entrenador auxiliar, Carmelo Campos, en aquellos primeros encuentros extraoficiales se hab&iacute;a hecho cargo del Marino hasta finalizar la Liguilla de Ascenso, actuando como entrenador y jugador del conjunto de "Fuera de la Portada" aunque todo su trabajo era en pro de la UD Las Palmas.</p>
<p>D. Jes&uacute;s Navarro llegaba con un amplio bagaje como jugador y t&eacute;cnico del Valencia y Atl&eacute;tico de Aviaci&oacute;n durante la Guerra Civil.</p>
<p>De regreso a la isla hab&iacute;a realizado grandes temporadas en el Marino y por &uacute;ltimo en el RC Victoria al que hab&iacute;a proclamado Campe&oacute;n de Campeones en el Campo de la Manzanilla en la &uacute;ltima temporada del club albinegro.</p>
<p>Era un entrenador de mucho genio y car&aacute;cter, y la profesi&oacute;n no ten&iacute;a secretos para &eacute;l. Sab&iacute;a dominar a la perfecci&oacute;n toda clase de situaciones".</p>
<p><strong style="font-size: 14px; line-height: 1.4;">De cuando el nombre de Boro no figuraba en las fichas del club.</strong></p>
<p><span style="line-height: 1.4;">En el cap&iacute;tulo de an&eacute;cdotas, Boro nos relata un buen n&uacute;mero de ellas aunque tambi&eacute;n nos hace saber que muchas no pueden salir a la luz ya que podr&iacute;an herir la susceptibilidad de sus protagonistas.</span></p>
<p>Al final le viene a la memoria una en particular con el directivo, y con posterioridad presidente de la entidad, D. Juan Trujillo Febles:</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113243859.jpg" width="296" height="388" /></p>
<p><em>Juan Trujillo Febles.</em></p>
<p>"Tanto a nivel futbol&iacute;stico como social, siempre he sido conocido por el diminutivo de Boro. Mi verdadero nombre s&oacute;lo lo utilizo en requisitos formales obligatorios.</p>
<p>En los primeros meses de haberse constituido el club, antes de comenzar los entrenamientos, todos ten&iacute;amos que pasar por el libro de registros y firmar.</p>
<p>Como se trataba de un acto oficial, escrib&iacute;a mi nombre y apellidos, Salvador Delgado Su&aacute;rez. Siempre me he considerado una persona responsable y disciplinada.</p>
<p>Un buen d&iacute;a, al comprobar que la totalidad de la plantilla hac&iacute;a tiempo que hab&iacute;a venido cobrando sus emolumentos, siendo yo la &uacute;nica excepci&oacute;n, le pregunt&eacute; a nuestro entra&ntilde;able utillero, Crist&oacute;bal "El Chato", con extra&ntilde;eza, si se hab&iacute;an olvidado de mi persona, haci&eacute;ndole saber las necesidades que hab&iacute;a en mi casa.</p>
<p>Juan Trujillo Febles, que hab&iacute;a sido presidente del Atl&eacute;tico Club, era uno de los directivos m&aacute;s implicados y entusiastas, desempe&ntilde;ando diversas funciones en la entidad. Ese d&iacute;a, lleg&oacute; muy temprano al Estadio Las Palmas, saliendo del vestuario de forma muy apresurada y con los &aacute;nimos muy exaltados, ordenando parar los ejercicios de precalentamiento y dirigi&eacute;ndose a la plantilla en tono intimidatorio para luego en alta voz afirmar: &iexcl;Aqu&iacute; falta un jugador! &iexcl;He venido observando que un futbolista que responde al nombre de Boro ha estado faltando a los entrenamientos, y a m&iacute; no me la juega nadie!</p>
<p>Cuando di un paso al frente y le hice saber que mi verdadero nombre era el de Salvador Delgado Su&aacute;rez, pero que desde que ten&iacute;a uso de raz&oacute;n todos me conoc&iacute;an por Boro, qued&oacute; por un instante perplejo. Luego, poni&eacute;ndose las manos en la cabeza en un gesto de contrariedad me espet&oacute;: &iexcl;Pero hombre, por Dios y los clavos de Cristo! &iquest;C&oacute;mo no me lo hab&iacute;a dicho antes? &iexcl;Me ha tenido usted&nbsp; toda la ma&ntilde;ana contando fichas y jugadores!</p>
<p>Al final me pidi&oacute; disculpas con un fuerte apret&oacute;n de manos, envi&aacute;ndome a la antigua sede social de Luis Ant&uacute;nez donde el cajero y primer empleado del club, L&aacute;zaro Guerra, se har&iacute;a cargo de las cantidades que me adeudaba la entidad".</p>
<p><strong style="font-size: 14px; line-height: 1.4;">La imprevisibilidad del f&uacute;tbol.</strong></p>
<p><span style="line-height: 1.4;">Como reza un proverbio ingl&eacute;s, "nothing ever comes at the right time", cuya versi&oacute;n no literal ser&iacute;a la de no dar nada por supuesto, ya que siempre puede surgir lo imprevisible o inesperado, Salvador Delgado (Boro), uno de los jugadores m&aacute;s prometedores de la plantilla fundacional, ver&iacute;a c&oacute;mo todos sus esfuerzos y sacrificios que hab&iacute;a tenido que solventar durante su trayectoria deportiva quedar&iacute;an inesperadamente truncados por una inoportuna lesi&oacute;n que le llegaba en el justo momento de su eclosi&oacute;n deportiva:</span></p>
<p>"El f&uacute;tbol y la vida en general tienen esos contratiempos imprevistos. Nunca me hab&iacute;a lesionado en todos los a&ntilde;os que jugu&eacute; en el Galdense o en el Arenas Club a pesar de dedicarme parcialmente a este deporte, y me viene a suceder este percance cuando mejor era mi preparaci&oacute;n y plena dedicaci&oacute;n.</p>
<p>Hab&iacute;a firmado un contrato como profesional de la entidad amarilla y mi responsabilidad era absoluta. Hab&iacute;a llegado a la c&uacute;spide pero&hellip;</p>
<p><strong style="font-size: 14px; line-height: 1.4;">Nuestro protagonista a&uacute;n se emociona al revivir la fecha de su debut en el reci&eacute;n creado equipo &uacute;nico.</strong></p>
<p><span style="line-height: 1.4;">"Debut&eacute; con la UD Las Palmas el 23 de octubre de 1949 en un encuentro de la denominada Liga Provincial Extra Oficial ante el Atl&eacute;tico Club, venciendo por el abultado resultado de seis tantos a uno.</span></p>
<p><span style="line-height: 1.4;">Aunque mi demarcaci&oacute;n era preferentemente la de medio centro, en ese encuentro formar&iacute;a en la defensa sustituyendo a Juanono que actuaba de central y estaba lesionado, teniendo como compa&ntilde;eros en la l&iacute;nea defensiva a Pantale&oacute;n y Viera. La porter&iacute;a la defend&iacute;a Manolo Montes, a mi entender el guardameta m&aacute;s completo en toda la historia del club.</span></p>
<p>Tanto Pantale&oacute;n como Montes ingresar&iacute;an con posterioridad en el Atl&eacute;tico de Madrid.</p>
<p>El otro lateral, Viera, era igualmente un defensa de gran colocaci&oacute;n y seguridad. Este jugador hab&iacute;a pertenecido muchos a&ntilde;os al Atl&eacute;tico Club y se sent&iacute;a extra&ntilde;o al tener que enfrentarse a sus compa&ntilde;eros e infringirles un resultado tan humillante. El f&uacute;tbol te depara a veces estas sorpresas. Al final este chico emigrar&iacute;a a Venezuela, seg&uacute;n tengo entendido.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113241260-b_result.jpg" width="396" height="594" /></p>
<p><em>Salvador Delgado Su&aacute;rez (Boro).</em></p>
<p>A medida que transcurr&iacute;an los d&iacute;as se iban incorporando nuevos jugadores como Casta&ntilde;ares, que se har&iacute;a con la titularidad en su demarcaci&oacute;n de defensa derecho".</p>
<p>Pr&oacute;ximo a llegar a nonagenario, Boro, a&uacute;n no ha podido olvidar su debut con la reci&eacute;n creada UD Las Palmas, emocion&aacute;ndose al recordar la andadura inicial del equipo &uacute;nico y todas sus vicisitudes entremezcladas con momentos de gloria: Representar a nuestro equipo en aquella etapa fundacional no se puede explicar con palabras; era un orgullo de pertenencia, una emoci&oacute;n indescriptible. Los tiempos han cambiado de forma sustancial. Nosotros, los que tuvimos el gran honor de vivir el nacimiento del club despu&eacute;s de haber pertenecido a los equipos hist&oacute;ricos fusionados, lo experiment&aacute;bamos como una identificaci&oacute;n emocional. En la jerarqu&iacute;a de valores de los jugadores de hoy en d&iacute;a priman otros intereses".</p>
<p>Aquella g&eacute;lida tarde del 23 de octubre de 1949 el once amarillo presentar&iacute;a ante el Atl&eacute;tico Club la siguiente alineaci&oacute;n: Manolo Montes; Boro, Pantale&oacute;n, Viera; Tatono, Polo; Rafael (El Rala), Manol&iacute;n, Nicol&aacute;s, Anto&ntilde;ito Jorge y Cedr&eacute;s.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113234761_result.jpg" width="586" height="415" /></p>
<p><em>Debut de Salvador Delgado Su&aacute;rez (Boro) con la UD Las Palmas ante el Atl&eacute;tico Club.</em></p>
<p><em>De izquierda a derecha, de pi&eacute;: Juanito Gil (masajista), Montes, Polo,Boro, Tatono, Pantale&oacute;n y Viera.</em></p>
<p><em>De rodillas: Rafael (El Rala), Manol&iacute;n, Nicol&aacute;s, A. Jorge y Cedr&eacute;s.</em></p>
<p><span style="line-height: 1.4;">Salvador Delgado (Boro) trata de hilvanar recuerdos de aquel encuentro mostrando una gran objetividad y nobleza al describir el desenlace final:</span></p>
<p>"En honor a la verdad hay que reconocer que a pesar del abultado resultado no realizamos un gran encuentro. En la primera mitad fue expulsado el guardameta atl&eacute;tico, Caballero, que era uno de sus grandes baluartes, luego las lesiones hicieron mella en el conjunto rojiblanco, llegando al final de la contienda con ocho jugadores sobre el terreno de juego.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113230062-caballero_result.jpg" width="427" height="641" /></p>
<p><em>Caballero.</em></p>
<p>En aquellos a&ntilde;os no se efectuaban cambios y fue necesario ubicar al delantero centro Talavera &ndash;uno de sus m&aacute;s peligrosos efectivos-&nbsp; en la porter&iacute;a, circunstancia que propiciar&iacute;a la debacle del cuadro atl&eacute;tico. Para agravar la situaci&oacute;n, el medio Guti&eacute;rrez y el extremo Blas no se encontraban en condiciones &oacute;ptimas para jugar, resinti&eacute;ndose de sus lesiones en la primera mitad del encuentro, quedando el once atl&eacute;tico considerablemente mermado.</p>
<p>Nuestro delantero centro, Nicol&aacute;s,&nbsp; que hab&iacute;a pertenecido en a&ntilde;os anteriores al Atl&eacute;tico y Marino, ser&iacute;a el h&eacute;roe de la jornada marcando cuatro tantos. El primer capit&aacute;n&nbsp; en la historia de la UD Las Palmas, Polo y el habilidoso Manol&iacute;n establecer&iacute;an los dos tantos restantes.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113222963_result.jpg" width="423" height="635" /></p>
<p><em>Nicol&aacute;s.</em></p>
<p>El &uacute;nico gol atl&eacute;tico fue obra del veloz extremo Capote en los inicios de la contienda.</p>
<p>El colegiado Sr. Acle que ven&iacute;a avalado de un gran prestigio, realizar&iacute;a un aceptable arbitraje, aunque excesivamente permisivo.</p>
<p>Tras un esperanzador debut en el conjunto amarillo y cuando m&aacute;s se reclamaba su presencia, el joven medio centro galdense desaparecer&iacute;a de las alineaciones fomentando su ausencia todo tipo de dudas y rumores:</p>
<p>"Al incorporarse al equipo el defensa Juanono tras su lesi&oacute;n de rodilla, era l&oacute;gico que volviera a su demarcaci&oacute;n habitual en la formaci&oacute;n titular.</p>
<p>En aquellos a&ntilde;os el "Pata Cuchar&oacute;n", como le apodaban, era una aut&eacute;ntica figura y garant&iacute;a en la retaguardia, siendo codiciado adem&aacute;s por grandes equipos de la Primera Divisi&oacute;n Nacional como el Valencia o el H&eacute;rcules de Alicante.</p>
<p>Mi demarcaci&oacute;n natural en el terreno de juego era la de medio centro a la antigua aunque en ocasiones, por alguna imperiosa necesidad, era ubicado en la defensa. Las t&aacute;cticas y ordenaci&oacute;n en el campo hab&iacute;an cambiado con la implantaci&oacute;n de la WM y yo ten&iacute;a que seguir esperando mi oportunidad. Aunque la media la formaban el malogrado Antonio Vieira y Polo, que se complementaban de forma extraordinaria, pude haber seguido formando en la alineaci&oacute;n titular en diferentes demarcaciones ya que as&iacute; me lo hac&iacute;an saber los t&eacute;cnicos. Sin embargo, cuando m&aacute;s ilusiones conceb&iacute;a y mayor era mi rendimiento y acoplamiento en el equipo, lleg&oacute; la inesperada lesi&oacute;n de rodilla, truncando todas mis esperanzas como profesional del f&uacute;tbol. A pesar de mi gran esfuerzo y voluntad por recuperarme y la atenci&oacute;n inestimable de los m&eacute;dicos del club, todo fue in&uacute;til. En aquellos tiempos la medicina deportiva distaba mucho de poseer las prestaciones de hoy. Las reca&iacute;das&nbsp; eran constantes hasta llegar a un punto de ser plenamente consciente de la realidad. Nunca podr&iacute;a volver a rendir a plenitud.</p>
<p>Siempre me he preguntado hasta d&oacute;nde pude haber llegado en el mundo del f&uacute;tbol de no haberse producido la grave lesi&oacute;n".</p>
<p><strong style="font-size: 14px; line-height: 1.4;">El factor suerte, cuesti&oacute;n primordial.</strong></p>
<p><span style="line-height: 1.4;">Desde tiempos inmemoriales se ha establecido el debate sobre la importancia que tiene el factor suerte en la trayectoria deportiva de un profesional del f&uacute;tbol. Nuestro entrevistado expone su criterio con firmeza y sin ninguna concesi&oacute;n &nbsp;a la duda:</span></p>
<p>"Es obvio que un jugador de f&uacute;tbol tiene que poseer unas cualidades innatas para este deporte. Sin embargo, aunque muchos opinan que el factor suerte no influye en el devenir de tu carrera deportiva, lamento estar en absoluto desacuerdo. Considero que hay factores externos decisivos para llegar a la c&uacute;spide y mantenerte en ella, que bien pueden ser de salud, familiares, profesionales, etc&hellip;</p>
<p>Considerando que hayas superado todos estos imponderables, el apoyo y continuidad que te puede ofrecer un entrenador es crucial y determinante. Podr&iacute;a ilustrar mi comentario con muchos ejemplos que son muy conocidos en el mundo del f&uacute;tbol. Tenemos el caso de Pantale&oacute;n&nbsp; o Juanito Beltr&aacute;n,&nbsp; que a base de una incre&iacute;ble fuerza de voluntad se convertir&iacute;a no s&oacute;lo en el &iacute;dolo de la afici&oacute;n canaria (figurando nuestro equipo en Primera Divisi&oacute;n) sino en defensa internacional. Todo ello fue debido a su constancia, pero no hay que olvidar la confianza que depositar&iacute;a en &eacute;l Satur Grech. Sin embargo, cuando atravesaba su mejor momento, todas sus ilusiones quedar&iacute;an en el camino ya que tras su grave lesi&oacute;n en la entrada en falso que efectu&oacute; al legendario Kubala no volver&iacute;a a ser el mismo.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113220264-a--beltr--n_result.jpg" width="390" height="585" /></p>
<p><em>Juanito Beltr&aacute;n (El Capit&aacute;n del Pa&ntilde;uelo).</em></p>
<p>&nbsp;</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113213564-b_result.jpg" width="415" height="824" /></p>
<p><em>Ladislao Kubala.</em></p>
<p>El caso de Manolo Naranjo, otro jugador suplente de Tatono, Vieira, Elzo, Ignacio, etc&hellip;, &nbsp;que con la llegada de Satur Grech al cargo se consolidar&iacute;a en la alineaci&oacute;n titular formando con Manolo Torres una de las mejores medias de Espa&ntilde;a; el caso de Paco Gento, un jugador veloz pero carente de t&eacute;cnica en el Racing de Santander y que tras su fichaje por el &nbsp;Real Madrid -gracias a las oportunidades que le brindaron los t&eacute;cnicos y a la inestimable ayuda de sus compa&ntilde;eros Rial y Di St&eacute;fano, que sab&iacute;an extraer su mejor rendimiento- se convertir&iacute;a en el mejor extremo del mundo.</p>
<p>&iquest;Qu&eacute; habr&iacute;a sido de jugadores como Manolo Montes o Manol&iacute;n de no haberse lesionado gravemente? Hoy, probablemente, estar&iacute;amos hablando de dos figuras del f&uacute;tbol nacional.</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113204165-manol--n-1_result.jpg" width="431" height="646" /></p>
<p><em>Manol&iacute;n.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113203266-montes_result.jpg" width="430" height="645" /></p>
<p><em>Montes.</em></p>
<p><span style="line-height: 1.4;">En este deporte pueden darse toda clase de circunstancias imprevisibles. Muchos son los que destacan y llegan pero pocos los que realmente se consolidan y triunfan".</span></p>
<p><span style="line-height: 1.4;">Rodeado de sus hijos Salvador e Isidro y de sus nietos, que tambi&eacute;n formaron parte de distintos clubes de la zona del noroeste,, Boro no se pierde un partido de los emitidos a nuestro equipo por televisi&oacute;n, aunque reconoce pasarlo mal en ocasiones debido a la intensidad con que vive los encuentros. Sobre establecer comparaciones entre el f&uacute;tbol actual y el de su tiempo, Boro no tiene ning&uacute;n g&eacute;nero de dudas:</span></p>
<p><span style="line-height: 1.4;">"Muchos dicen que de ni&ntilde;o se magnifica todo lo que puede ser causa de admiraci&oacute;n o sorpresa. Yo no estoy de acuerdo en esa apreciaci&oacute;n. No existe ninguna duda que la preparaci&oacute;n f&iacute;sica de hoy es superior a la de mis tiempos y el f&uacute;tbol se juega visiblemente a otro ritmo. Sin embargo en mis tiempos todos los ni&ntilde;os jug&aacute;bamos al f&uacute;tbol a todas horas y hoy no ves a nadie ejercitarse con el bal&oacute;n. Se ha perdido la calidad t&eacute;cnica y el dominio de bal&oacute;n. &iquest;D&oacute;nde se ven en la actualidad jugadores como Alfonso Silva, Luis Molowny, Rafael Mujica, Rosendo Hern&aacute;ndez, Paco Campos o Pacuco Jorge? Los partidos se viv&iacute;an con enorme emoci&oacute;n y durante toda la semana no se hablaba de otro tema. Hoy me da pena ver&nbsp; todos los estadios con las gradas vac&iacute;as, exceptuando los grandes equipos.</span></p>
<p><strong style="font-size: 14px; line-height: 1.4;">&iexcl;C&oacute;mo han pasado los a&ntilde;os!</strong></p>
<p><span style="line-height: 1.4;">Despu&eacute;s de su retirada como jugador en activo, Boro regres&oacute; a su G&aacute;ldar natal y lleg&oacute; a colaborar en algunos encuentros con su ex equipo, al igual que en partidos de veteranos:</span></p>
<p>"Tras mi lesi&oacute;n no pod&iacute;a rendir a plenitud pero mi afici&oacute;n por el f&uacute;tbol era tan grande &nbsp;que segu&iacute; ayudando en algunos partidos al CD G&aacute;ldar. Con posterioridad me dediqu&eacute; a entrenar a equipos como el Infantil Uni&oacute;n Moral y al Galdense en regionales.</p>
<p>Era un entrenador exigente y me gustaba el respeto, y los chicos de hoy en d&iacute;a, con condiciones,&nbsp; no est&aacute;n dispuestos a sacrificarse.</p>
<p>Desde mi retirada s&oacute;lo volv&iacute;&nbsp; al estadio en contadas ocasiones. Me alegr&eacute; mucho cuando usted comenz&oacute; a escribir la historia de la UD Las Palmas en la d&eacute;cada de los ochenta y con posterioridad cuando fueron publicados en los inicios de los noventa ya que antes no ten&iacute;a constancia de ning&uacute;n otro libro que narrara los hechos vividos en mi &eacute;poca. Del mismo modo cuando la UD Las Palmas vino a G&aacute;ldar con motivo de la inauguraci&oacute;n del "Estadio Chanito Tacoronte", en Ca&ntilde;ada Honda. Por aquellas fechas entrenaba al equipo amarillo Josu Uribe, que realiz&oacute; una buena temporada. El alcalde de G&aacute;ldar, Demetrio Su&aacute;rez, me pidi&oacute; que realizara el saque de honor, entreg&aacute;ndome una placa como homenaje a mi persona. Fue la &uacute;ltima vez que he presenciado un partido en directo".</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113200267.jpg" width="592" height="412" /></p>
<p><em>D&iacute;a de la inauguraci&oacute;n del Estadio Chanito Tacoronte en Ca&ntilde;ada Honda. En la imagen el ex jugador fundacional de la UD Las Palmas efectuando el saque de honor antes del comienzo del encuentro.</em></p>
<p>El fallecimiento de su esposa, Candelaria Vera Rodr&iacute;guez, ha sido un duro golpe para Boro, quien no deja de mencionarla constantemente:</p>
<p>"&Eacute;ramos novios desde ni&ntilde;os, y no iba a ning&uacute;n sitio sin ella. Pero el destino te da estos imprevistos. Ella, que ante mi incapacidad me cuidaba en todo momento con sumo esmero, se nos fue antes. Sin embargo, el estar rodeado constantemente de mi familia mitiga en parte mi dolor y me hace a&uacute;n sentir ilusi&oacute;n. Espero que su visita y la de sus colaboradores se repita con m&aacute;s frecuencia. No sabe usted la alegr&iacute;a que significa para m&iacute; revivir aquellos tiempos. &iexcl;C&oacute;mo han pasado los a&ntilde;os!"</p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113190568.jpg.jpg" width="555" height="416" /></p>
<p><em>El consejero e historiador del club, Antonio de Armas y Salvador Delgado Su&aacute;rez (Boro) posan en el domicilio del ex jugador amarillo.</em></p>
<p><img src="https://l10preunestawamb.blob.core.windows.net/lpa/images/legacy/201506/662x372a_1113184069.jpg.jpg" width="553" height="414" /></p>
<p><em>Salvador Delgado Su&aacute;rez en compa&ntilde;&iacute;a de su hijo Isidro, su nieto y el miembro del departamento de historia del club, Jos&eacute; Manuel Y&aacute;nez.</em></p>
<div>
<p>Despedimos a Boro rodeado de todos sus seres queridos que lo veneran con verdadera devoci&oacute;n. En su rostro sonriente pude vislumbrar fortaleza y paz interior; un ansia juvenil que le transportaba a un esplendor lejano.</p>
<p>Al dejar el rec&oacute;ndito lugar con mis compa&ntilde;eros del departamento de historia del club pens&eacute; en todas aquellas personas ya desaparecidas que un d&iacute;a muy lejano contribuyeron a incrementar la grandeza de esta instituci&oacute;n. Un club que hab&iacute;a nacido de la uni&oacute;n de todos los canarios y que habr&iacute;a de llevar por nombre UD Las Palmas.</p>
</div>
<p>&nbsp;</p>
